GOLDEN HOUR

DIR: /home/reseprot/public_html/tokomesinjakarta.com/wp-includes/js/dist

Name	Size	Action
a11y.js	10.41 KB
a11y.min.js	3 KB
annotations.js	34.53 KB
annotations.min.js	8.14 KB
api-fetch.js	23.77 KB
api-fetch.min.js	5.93 KB
autop.js	18 KB
autop.min.js	6.16 KB
blob.js	6.02 KB
blob.min.js	1.54 KB
block-directory.js	61.99 KB
block-directory.min.js	21.59 KB
block-editor.js	1.68 MB
block-editor.min.js	525.41 KB
block-library.js	1.31 MB
block-library.min.js	587.2 KB
block-serialization-default-parser.js	14.7 KB
block-serialization-default-parser.min.js	2.94 KB
blocks.js	472.07 KB
blocks.min.js	154.84 KB
components.js	2.31 MB
components.min.js	769.75 KB
compose.js	152.74 KB
compose.min.js	35.95 KB
core-data.js	175.52 KB
core-data.min.js	47.55 KB
customize-widgets.js	138.8 KB
customize-widgets.min.js	49.56 KB
data-controls.js	9.36 KB
data-controls.min.js	2.23 KB
data.js	130.02 KB
data.min.js	23.88 KB
date.js	231.08 KB
date.min.js	197.52 KB
deprecated.js	7.65 KB
deprecated.min.js	1.61 KB
dom-ready.js	5.02 KB
dom-ready.min.js	1.23 KB
dom.js	62.61 KB
dom.min.js	13.23 KB
edit-post.js	340.89 KB
edit-post.min.js	118.39 KB
edit-site.js	401.39 KB
edit-site.min.js	144.04 KB
edit-widgets.js	176.56 KB
edit-widgets.min.js	62.18 KB
editor.js	394.49 KB
editor.min.js	138.37 KB
element.js	43.2 KB
element.min.js	9.42 KB
escape-html.js	8.59 KB
escape-html.min.js	1.74 KB
format-library.js	62.92 KB
format-library.min.js	21.41 KB
hooks.js	23 KB
hooks.min.js	5.56 KB
html-entities.js	5.7 KB
html-entities.min.js	1.38 KB
i18n.js	50.39 KB
i18n.min.js	10.16 KB
is-shallow-equal.js	6.53 KB
is-shallow-equal.min.js	1.66 KB
keyboard-shortcuts.js	25.7 KB
keyboard-shortcuts.min.js	5.47 KB
keycodes.js	16.4 KB
keycodes.min.js	4.05 KB
list-reusable-blocks.js	13.95 KB
list-reusable-blocks.min.js	5.19 KB
media-utils.js	24.11 KB
media-utils.min.js	7.98 KB
notices.js	17.07 KB
notices.min.js	3.04 KB
nux.js	24.52 KB
nux.min.js	6.03 KB
plugins.js	21.42 KB
plugins.min.js	5.3 KB
primitives.js	10.23 KB
primitives.min.js	2.83 KB
priority-queue.js	8.73 KB
priority-queue.min.js	1.6 KB
redux-routine.js	25.08 KB
redux-routine.min.js	9.57 KB
reusable-blocks.js	20.9 KB
reusable-blocks.min.js	6.79 KB
rich-text.js	142.25 KB
rich-text.min.js	35.88 KB
server-side-render.js	15.29 KB
server-side-render.min.js	4.68 KB
shortcode.js	19 KB
shortcode.min.js	3.96 KB
token-list.js	9.89 KB
token-list.min.js	2.28 KB
url.js	28.54 KB
url.min.js	5.56 KB
[ vendor ]	-
viewport.js	13.6 KB
viewport.min.js	3.06 KB
warning.js	10.83 KB
warning.min.js	2.86 KB
widgets.js	55.28 KB
widgets.min.js	22.16 KB
wordcount.js	17.32 KB
wordcount.min.js	3.18 KB

Edit: block-serialization-default-parser.js

this["wp"] = this["wp"] || {}; this["wp"]["blockSerializationDefaultParser"] =
/******/ (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] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = 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;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = "SiJt");
/******/ })
/************************************************************************/
/******/ ({

/***/ "SiJt":
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "parse", function() { return parse; });
let document;
let offset;
let output;
let stack;
/**
 * Matches block comment delimiters
 *
 * While most of this pattern is straightforward the attribute parsing
 * incorporates a tricks to make sure we don't choke on specific input
 *
 *  - since JavaScript has no possessive quantifier or atomic grouping
 *    we are emulating it with a trick
 *
 *    we want a possessive quantifier or atomic group to prevent backtracking
 *    on the `}`s should we fail to match the remainder of the pattern
 *
 *    we can emulate this with a positive lookahead and back reference
 *    (a++)*c === ((?=(a+))\1)*c
 *
 *    let's examine an example:
 *      - /(a+)*c/.test('aaaaaaaaaaaaad') fails after over 49,000 steps
 *      - /(a++)*c/.test('aaaaaaaaaaaaad') fails after 85 steps
 *      - /(?>a+)*c/.test('aaaaaaaaaaaaad') fails after 126 steps
 *
 *    this is because the possessive `++` and the atomic group `(?>)`
 *    tell the engine that all those `a`s belong together as a single group
 *    and so it won't split it up when stepping backwards to try and match
 *
 *    if we use /((?=(a+))\1)*c/ then we get the same behavior as the atomic group
 *    or possessive and prevent the backtracking because the `a+` is matched but
 *    not captured. thus, we find the long string of `a`s and remember it, then
 *    reference it as a whole unit inside our pattern
 *
 *    @see http://instanceof.me/post/52245507631/regex-emulate-atomic-grouping-with-lookahead
 *    @see http://blog.stevenlevithan.com/archives/mimic-atomic-groups
 *    @see https://javascript.info/regexp-infinite-backtracking-problem
 *
 *    once browsers reliably support atomic grouping or possessive
 *    quantifiers natively we should remove this trick and simplify
 *
 * @type {RegExp}
 *
 * @since 3.8.0
 * @since 4.6.1 added optimization to prevent backtracking on attribute parsing
 */

const tokenizer = /)[^])*)\5|[^]*?)}\s+)?(\/)?-->/g;

function Block(blockName, attrs, innerBlocks, innerHTML, innerContent) {
  return {
    blockName,
    attrs,
    innerBlocks,
    innerHTML,
    innerContent
  };
}

function Freeform(innerHTML) {
  return Block(null, {}, [], innerHTML, [innerHTML]);
}

const parse = doc => {
  document = doc;
  offset = 0;
  output = [];
  stack = [];
  tokenizer.lastIndex = 0;

do {// twiddle our thumbs
  } while (proceed());

return output;
};

function proceed() {
  const next = nextToken();
  const [tokenType, blockName, attrs, startOffset, tokenLength] = next;
  const stackDepth = stack.length; // we may have some HTML soup before the next block

const leadingHtmlStart = startOffset > offset ? offset : null;

switch (tokenType) {
    case 'no-more-tokens':
      // if not in a block then flush output
      if (0 === stackDepth) {
        addFreeform();
        return false;
      } // Otherwise we have a problem
      // This is an error
      // we have options
      //  - treat it all as freeform text
      //  - assume an implicit closer (easiest when not nesting)
      // for the easy case we'll assume an implicit closer

if (1 === stackDepth) {
        addBlockFromStack();
        return false;
      } // for the nested case where it's more difficult we'll
      // have to assume that multiple closers are missing
      // and so we'll collapse the whole stack piecewise

while (0 < stack.length) {
        addBlockFromStack();
      }

return false;

case 'void-block':
      // easy case is if we stumbled upon a void block
      // in the top-level of the document
      if (0 === stackDepth) {
        if (null !== leadingHtmlStart) {
          output.push(Freeform(document.substr(leadingHtmlStart, startOffset - leadingHtmlStart)));
        }

output.push(Block(blockName, attrs, [], '', []));
        offset = startOffset + tokenLength;
        return true;
      } // otherwise we found an inner block

addInnerBlock(Block(blockName, attrs, [], '', []), startOffset, tokenLength);
      offset = startOffset + tokenLength;
      return true;

case 'block-opener':
      // track all newly-opened blocks on the stack
      stack.push(Frame(Block(blockName, attrs, [], '', []), startOffset, tokenLength, startOffset + tokenLength, leadingHtmlStart));
      offset = startOffset + tokenLength;
      return true;

case 'block-closer':
      // if we're missing an opener we're in trouble
      // This is an error
      if (0 === stackDepth) {
        // we have options
        //  - assume an implicit opener
        //  - assume _this_ is the opener
        //  - give up and close out the document
        addFreeform();
        return false;
      } // if we're not nesting then this is easy - close the block

if (1 === stackDepth) {
        addBlockFromStack(startOffset);
        offset = startOffset + tokenLength;
        return true;
      } // otherwise we're nested and we have to close out the current
      // block and add it as a innerBlock to the parent

const stackTop = stack.pop();
      const html = document.substr(stackTop.prevOffset, startOffset - stackTop.prevOffset);
      stackTop.block.innerHTML += html;
      stackTop.block.innerContent.push(html);
      stackTop.prevOffset = startOffset + tokenLength;
      addInnerBlock(stackTop.block, stackTop.tokenStart, stackTop.tokenLength, startOffset + tokenLength);
      offset = startOffset + tokenLength;
      return true;

default:
      // This is an error
      addFreeform();
      return false;
  }
}
/**
 * Parse JSON if valid, otherwise return null
 *
 * Note that JSON coming from the block comment
 * delimiters is constrained to be an object
 * and cannot be things like `true` or `null`
 *
 * @param {string} input JSON input string to parse
 * @return {Object|null} parsed JSON if valid
 */

function parseJSON(input) {
  try {
    return JSON.parse(input);
  } catch (e) {
    return null;
  }
}

function nextToken() {
  // aye the magic
  // we're using a single RegExp to tokenize the block comment delimiters
  // we're also using a trick here because the only difference between a
  // block opener and a block closer is the leading `/` before `wp:` (and
  // a closer has no attributes). we can trap them both and process the
  // match back in JavaScript to see which one it was.
  const matches = tokenizer.exec(document); // we have no more tokens

if (null === matches) {
    return ['no-more-tokens'];
  }

const startedAt = matches.index;
  const [match, closerMatch, namespaceMatch, nameMatch, attrsMatch
  /* internal/unused */
  ,, voidMatch] = matches;
  const length = match.length;
  const isCloser = !!closerMatch;
  const isVoid = !!voidMatch;
  const namespace = namespaceMatch || 'core/';
  const name = namespace + nameMatch;
  const hasAttrs = !!attrsMatch;
  const attrs = hasAttrs ? parseJSON(attrsMatch) : {}; // This state isn't allowed
  // This is an error

if (isCloser && (isVoid || hasAttrs)) {// we can ignore them since they don't hurt anything
    // we may warn against this at some point or reject it
  }

if (isVoid) {
    return ['void-block', name, attrs, startedAt, length];
  }

if (isCloser) {
    return ['block-closer', name, null, startedAt, length];
  }

return ['block-opener', name, attrs, startedAt, length];
}

function addFreeform(rawLength) {
  const length = rawLength ? rawLength : document.length - offset;

if (0 === length) {
    return;
  }

output.push(Freeform(document.substr(offset, length)));
}

function addInnerBlock(block, tokenStart, tokenLength, lastOffset) {
  const parent = stack[stack.length - 1];
  parent.block.innerBlocks.push(block);
  const html = document.substr(parent.prevOffset, tokenStart - parent.prevOffset);

if (html) {
    parent.block.innerHTML += html;
    parent.block.innerContent.push(html);
  }

parent.block.innerContent.push(null);
  parent.prevOffset = lastOffset ? lastOffset : tokenStart + tokenLength;
}

function addBlockFromStack(endOffset) {
  const {
    block,
    leadingHtmlStart,
    prevOffset,
    tokenStart
  } = stack.pop();
  const html = endOffset ? document.substr(prevOffset, endOffset - prevOffset) : document.substr(prevOffset);

if (html) {
    block.innerHTML += html;
    block.innerContent.push(html);
  }

if (null !== leadingHtmlStart) {
    output.push(Freeform(document.substr(leadingHtmlStart, tokenStart - leadingHtmlStart)));
  }

output.push(block);
}

/***/ })

/******/ });

GOLDEN HOUR

Edit: block-serialization-default-parser.js

TERMINAL