taking the normal format and putting it back page.start -> start page.end -> end
355955
function(raw){
                    var clone = canReflect.serialize(raw);
                    if(clone.page) {
                        clone[offset] = clone.page.start;
                        clone[limit] = (clone.page.end - clone.page.start) + 1;
                        delete clone.page;
                    }
                    return clone;
                }
717246
@Override
    public void startOfProcess() {
        String previousBaseIndent = baseIndent.substring(INDENT_LENGTH);
        builder.append(previousBaseIndent).append("HierarchyWrapper{\n");
        processFirstOtherContent = true;
    }
415542
function strip(start, end) {
        const before = template.slice(0, start)
        const target = template.slice(start, end)
        const after = template.slice(end)
        template = before + target.replace(/\S/gu, " ") + after
        stripedRanges.push([start, end])
    }
1270882
protected function end()
    {
        // stop recording block
        $content = ob_get_clean();

        // read record
        list($name, $rewrite) = $this->record;

        // rewrite
        if($rewrite) {
            $this->blocks += [$name => $content];
        }
        // render
        else {
            echo isset($this->blocks[$name])
                ? $this->blocks[$name]
                : $content;
        }

        // reset record
        $this->record = null;
    }
385319
def finish(*args, &block)
      self['Content-Type'] ||= 'text/html;charset=utf-8'
      @block = block if block
      if [204, 205, 304].include?(status.to_i)
        header.delete "Content-Type"
        header.delete "Content-Length"
        close
        [status.to_i, header, []]
      else
        [status.to_i, header, body]
      end
    end
720232
public function end()
	{
		if ($this->config['layout'] !== false && is_file($file = $this->getLayoutPath()) ) {
			extract($this->data, EXTR_OVERWRITE|EXTR_REFS);
            require($this->cache($file, true));
		}
	}
1032419
function normalizePage(sections, options) {
    options = _.defaults(options || {}, {
        // Current book
        book: null,

        // Do we need to convert svg?
        convertImages: false,

        // Current file path
        input: '.',

        // Navigation to use to transform path
        navigation: {},

        // Directory parent of the file currently in rendering process
        base: './',

        // Directory parent from the html output
        output: './',

        // Glossary terms
        glossary: []
    });

    // List of images to convert
    var toConvert = [];

    sections = _.map(sections, function(section) {
        if (section.type != 'normal') return section;

        var out = normalizeHtml(section.content, options);

        toConvert = toConvert.concat(out.images);
        section.content = out.html;
        return section;
    });

    return Q()
    .then(function() {
        toConvert = _.uniq(toConvert, 'source');
        return convertImages(toConvert, options);
    })
    .thenResolve(sections);
}
415352
def _handle_end_way(self):
        
        self._result.append(Way(result=self._result, **self._curr))
        self._curr = {}
734485
function(page) {

            var $ = cheerio.load(page.content);

            // Replace top level li.chapter with li.part
            $('ul.summary > li.chapter').each(function(i, elem) {
                var li = $(elem);

                // Replace the classes if the chapter is actually a part, and add a divider
                if (li.text().indexOf('-XPARTX-') > 0) {
                    li.removeClass('chapter');
                    li.addClass('part');

                    // Don't add a divider before the first part, let it come straight after the Introduction page
                    if (i > 1)
                        li.before('<li class="part divider" />');
                }
            });

            // remove chapter numbers from any intro pages (and child pages)
            $('ul.summary > li.chapter span > b').remove();
            $('ul.summary > li.chapter a > b').remove();

            // Remove the chapter number from the part header
            $('ul.summary > li.part > span > b').remove();
            $('ul.summary > li.part > a > b').remove();

            // Replace the nasty munging of the name for part heading
            $('ul.summary > li.part > span').each(function(i, elem) {
                var span = $(elem);
                span.text(span.text().replace(/-XPARTX-/, ""));
            });

            // Bump the remaining chapter numbers so each chapter is only unique
            // within the part
            $('ul.summary > li.part li.chapter b').each(function(i, elem) {
                var b = $(elem);
                var text = b.text();
                var index = text.indexOf('.');
                if (index > -1)
                    b.text(text.substring(index + 1));
            });

            page.content = $.html();
            return page;
        }
81156
def end(self):
        """"""
        for comic in self.data:
            with codecs.open(self.jsonFn(comic), 'w', self.encoding) as f:
                json.dump(self.data[comic], f, indent=2, separators=(',', ': '), sort_keys=True)
1038506
function () {
            var me = this;
            return new Range(me.document).setStart(me.startContainer, me.startOffset).setEnd(me.endContainer, me.endOffset);

        }
778251
def _handle_end_node(self):
        
        self._result.append(Node(result=self._result, **self._curr))
        self._curr = {}
505773
function () /*:Void*/ {

        //set the current page
        this._curPage = this._pages.shift();

        this.fire(this.TEST_PAGE_BEGIN_EVENT, this._curPage);

        //load the frame - destroy history in case there are other iframes that
        //need testing
        this._frame.location.replace(this._curPage);

    }
134785
def end_state(self):
        

        # Make sure we append any trailing text
        if self.str_begin != len(self.format):
            if len(self.state) > 1 or self.state[-1] != 'string':
                self.fmt.append_text(
                    "(Bad format string; ended in state %r)" % self.state[-1])
            else:
                self.fmt.append_text(self.format[self.str_begin:])

        # Convenience return
        return self.fmt
497419
function (currentPage) {
			this.writeDebug('paginationSetup',arguments);
			var pagesOutput = '';
			var totalPages;
			var $paginationList = $('.bh-sl-pagination-container .bh-sl-pagination');

			// Total pages
			if ( this.settings.storeLimit === -1 || locationset.length < this.settings.storeLimit ) {
				totalPages = locationset.length / this.settings.locationsPerPage;
			} else {
				totalPages = this.settings.storeLimit / this.settings.locationsPerPage;
			}

			// Current page check
			if (typeof currentPage === 'undefined') {
				currentPage = 0;
			}

			// Initial pagination setup
			if ($paginationList.length === 0) {

				pagesOutput = this._paginationOutput(currentPage, totalPages);
			}
			// Update pagination on page change
			else {
				// Remove the old pagination
				$paginationList.empty();

				// Add the numbers
				pagesOutput = this._paginationOutput(currentPage, totalPages);
			}

			$paginationList.append(pagesOutput);
		}
1024558
def _parse_pages(self, unicode=False):
    """"""
    if self.pageRange:
        pages = 'pp. {}'.format(self.pageRange)
    elif self.startingPage:
        pages = 'pp. {}-{}'.format(self.startingPage, self.endingPage)
    else:
        pages = '(no pages found)'
    if unicode:
        pages = u'{}'.format(pages)
    return pages
357530
def move_page_bottom(self):
        
        self.nav.page_index = self.content.range[1]
        self.nav.cursor_index = 0
        self.nav.inverted = True