@markuplint/parser-utils 1.6.1 → 2.0.0-dev.23

package/lib/idl-attributes.js

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchIDLAttribute = void 0;
+/**
+ * IDL attributes VS Content attributes
+ */
+const idlContentMap = {
+    // HTML
+    accept: 'accept',
+    acceptCharset: 'acceptcharset',
+    accessKey: 'accesskey',
+    action: 'action',
+    allowFullScreen: 'allowfullscreen',
+    alt: 'alt',
+    as: 'as',
+    async: 'async',
+    autoCapitalize: 'autocapitalize',
+    autoComplete: 'autocomplete',
+    autoCorrect: 'autocorrect',
+    autoFocus: 'autofocus',
+    autoPlay: 'autoplay',
+    autoSave: 'autosave',
+    capture: 'capture',
+    cellPadding: 'cellpadding',
+    cellSpacing: 'cellspacing',
+    challenge: 'challenge',
+    charSet: 'charset',
+    checked: 'checked',
+    cite: 'cite',
+    classID: 'classid',
+    className: 'class',
+    cols: 'cols',
+    colSpan: 'colspan',
+    content: 'content',
+    contentEditable: 'contenteditable',
+    contextMenu: 'contextmenu',
+    controls: 'controls',
+    controlsList: 'controlslist',
+    coords: 'coords',
+    crossOrigin: 'crossorigin',
+    data: 'data',
+    dateTime: 'datetime',
+    default: 'default',
+    defer: 'defer',
+    dir: 'dir',
+    disabled: 'disabled',
+    disablePictureInPicture: 'disablepictureinpicture',
+    disableRemotePlayback: 'disableremoteplayback',
+    download: 'download',
+    draggable: 'draggable',
+    encType: 'enctype',
+    enterKeyHint: 'enterkeyhint',
+    form: 'form',
+    formAction: 'formaction',
+    formEncType: 'formenctype',
+    formMethod: 'formmethod',
+    formNoValidate: 'formnovalidate',
+    formTarget: 'formtarget',
+    frameBorder: 'frameborder',
+    headers: 'headers',
+    height: 'height',
+    hidden: 'hidden',
+    high: 'high',
+    href: 'href',
+    hrefLang: 'hreflang',
+    htmlFor: 'for',
+    httpEquiv: 'httpequiv',
+    icon: 'icon',
+    id: 'id',
+    inputMode: 'inputmode',
+    integrity: 'integrity',
+    is: 'is',
+    itemID: 'itemid',
+    itemProp: 'itemprop',
+    itemRef: 'itemref',
+    itemScope: 'itemscope',
+    itemType: 'itemtype',
+    keyParams: 'keyparams',
+    keyType: 'keytype',
+    kind: 'kind',
+    label: 'label',
+    lang: 'lang',
+    list: 'list',
+    loop: 'loop',
+    low: 'low',
+    manifest: 'manifest',
+    marginHeight: 'marginheight',
+    marginWidth: 'marginwidth',
+    max: 'max',
+    maxLength: 'maxlength',
+    media: 'media',
+    mediaGroup: 'mediagroup',
+    method: 'method',
+    min: 'min',
+    minLength: 'minlength',
+    multiple: 'multiple',
+    muted: 'muted',
+    name: 'name',
+    noModule: 'nomodule',
+    nonce: 'nonce',
+    noValidate: 'novalidate',
+    open: 'open',
+    optimum: 'optimum',
+    pattern: 'pattern',
+    placeholder: 'placeholder',
+    playsInline: 'playsinline',
+    poster: 'poster',
+    preload: 'preload',
+    profile: 'profile',
+    radioGroup: 'radiogroup',
+    readOnly: 'readonly',
+    referrerPolicy: 'referrerpolicy',
+    rel: 'rel',
+    required: 'required',
+    reversed: 'reversed',
+    role: 'role',
+    rows: 'rows',
+    rowSpan: 'rowspan',
+    sandbox: 'sandbox',
+    scope: 'scope',
+    scoped: 'scoped',
+    scrolling: 'scrolling',
+    seamless: 'seamless',
+    selected: 'selected',
+    shape: 'shape',
+    size: 'size',
+    sizes: 'sizes',
+    span: 'span',
+    spellCheck: 'spellcheck',
+    src: 'src',
+    srcDoc: 'srcdoc',
+    srcLang: 'srclang',
+    srcSet: 'srcset',
+    start: 'start',
+    step: 'step',
+    style: 'style',
+    summary: 'summary',
+    tabIndex: 'tabindex',
+    target: 'target',
+    title: 'title',
+    type: 'type',
+    useMap: 'usemap',
+    value: 'value',
+    width: 'width',
+    wmode: 'wmode',
+    wrap: 'wrap',
+    // SVG
+    accentHeight: 'accent-height',
+    accumulate: 'accumulate',
+    additive: 'additive',
+    alignmentBaseline: 'alignment-baseline',
+    alphabetic: 'alphabetic',
+    amplitude: 'amplitude',
+    arabicForm: 'arabic-form',
+    ascent: 'ascent',
+    attributeName: 'attributeName',
+    attributeType: 'attributeType',
+    azimuth: 'azimuth',
+    baseFrequency: 'baseFrequency',
+    baselineShift: 'baseline-shift',
+    baseProfile: 'baseProfile',
+    bbox: 'bbox',
+    begin: 'begin',
+    bias: 'bias',
+    by: 'by',
+    calcMode: 'calcMode',
+    capHeight: 'cap-height',
+    clip: 'clip',
+    clipPath: 'clipPathUnits',
+    clipPathUnits: 'clip-path',
+    clipRule: 'clip-rule',
+    color: 'color',
+    colorInterpolation: 'color-interpolation',
+    colorInterpolationFilters: 'color-interpolation-filters',
+    colorProfile: 'color-profile',
+    colorRendering: 'color-rendering',
+    contentScriptType: 'contentScriptType',
+    contentStyleType: 'contentStyleType',
+    cursor: 'cursor',
+    cx: 'cx',
+    cy: 'cy',
+    d: 'd',
+    decelerate: 'decelerate',
+    descent: 'descent',
+    diffuseConstant: 'diffuseConstant',
+    direction: 'direction',
+    display: 'display',
+    divisor: 'divisor',
+    dominantBaseline: 'dominant-baseline',
+    dur: 'dur',
+    dx: 'dx',
+    dy: 'dy',
+    edgeMode: 'edgeMode',
+    elevation: 'elevation',
+    enableBackground: 'enable-background',
+    end: 'end',
+    exponent: 'exponent',
+    fill: 'fill',
+    fillOpacity: 'fill-opacity',
+    fillRule: 'fill-rule',
+    filter: 'filter',
+    filterRes: 'filterRes',
+    filterUnits: 'filterUnits',
+    floodColor: 'flood-color',
+    floodOpacity: 'flood-opacity',
+    focusable: 'focusable',
+    fontFamily: 'font-family',
+    fontSize: 'font-size',
+    fontSizeAdjust: 'font-size-adjust',
+    fontStretch: 'font-stretch',
+    fontStyle: 'font-style',
+    fontVariant: 'font-variant',
+    fontWeight: 'font-weight',
+    format: 'format',
+    from: 'from',
+    fr: 'fr',
+    fx: 'fx',
+    fy: 'fy',
+    g1: 'g1',
+    g2: 'g2',
+    glyphName: 'glyph-name',
+    glyphOrientationHorizontal: 'glyph-orientation-horizontal',
+    glyphOrientationVertical: 'glyph-orientation-vertical',
+    glyphRef: 'glyphRef',
+    gradientTransform: 'gradientTransform',
+    gradientUnits: 'gradientUnits',
+    hanging: 'hanging',
+    horizAdvX: 'horiz-adv-x',
+    horizOriginX: 'horiz-origin-x',
+    ideographic: 'ideographic',
+    imageRendering: 'image-rendering',
+    in: 'in',
+    in2: 'in2',
+    intercept: 'intercept',
+    k: 'k',
+    k1: 'k1',
+    k2: 'k2',
+    k3: 'k3',
+    k4: 'k4',
+    kernelMatrix: 'kernelMatrix',
+    kernelUnitLength: 'kernelUnitLength',
+    kerning: 'kerning',
+    keyPoints: 'keyPoints',
+    keySplines: 'keySplines',
+    keyTimes: 'keyTimes',
+    lengthAdjust: 'lengthAdjust',
+    letterSpacing: 'letter-spacing',
+    lightingColor: 'lighting-color',
+    limitingConeAngle: 'limitingConeAngle',
+    local: 'local',
+    markerEnd: 'marker-end',
+    markerHeight: 'markerHeight',
+    markerMid: 'marker-mid',
+    markerStart: 'marker-start',
+    markerUnits: 'markerUnits',
+    markerWidth: 'markerWidth',
+    mask: 'mask',
+    maskContentUnits: 'maskContentUnits',
+    maskUnits: 'maskUnits',
+    mathematical: 'mathematical',
+    mode: 'mode',
+    numOctaves: 'numOctaves',
+    offset: 'offset',
+    opacity: 'opacity',
+    operator: 'operator',
+    order: 'order',
+    orient: 'orient',
+    orientation: 'orientation',
+    origin: 'origin',
+    overflow: 'overflow',
+    overlinePosition: 'overline-position',
+    overlineThickness: 'overline-thickness',
+    paintOrder: 'paint-order',
+    panose1: 'panose-1',
+    pathLength: 'pathLength',
+    patternContentUnits: 'patternContentUnits',
+    patternTransform: 'patternTransform',
+    patternUnits: 'patternUnits',
+    pointerEvents: 'pointer-events',
+    points: 'points',
+    pointsAtX: 'pointsAtX',
+    pointsAtY: 'pointsAtY',
+    pointsAtZ: 'pointsAtZ',
+    preserveAlpha: 'preserveAlpha',
+    preserveAspectRatio: 'preserveAspectRatio',
+    primitiveUnits: 'primitiveUnits',
+    r: 'r',
+    refX: 'refX',
+    refY: 'refY',
+    renderingIntent: 'rendering-intent',
+    repeatCount: 'repeatCount',
+    repeatDur: 'repeatDur',
+    requiredExtensions: 'requiredExtensions',
+    requiredFeatures: 'requiredFeatures',
+    restart: 'restart',
+    result: 'result',
+    rotate: 'rotate',
+    rx: 'rx',
+    ry: 'ry',
+    scale: 'scale',
+    seed: 'seed',
+    shapeRendering: 'shape-rendering',
+    slope: 'slope',
+    spacing: 'spacing',
+    specularConstant: 'specularConstant',
+    specularExponent: 'specularExponent',
+    speed: 'speed',
+    spreadMethod: 'spreadMethod',
+    startOffset: 'startOffset',
+    stdDeviation: 'stdDeviation',
+    stemh: 'stemh',
+    stemv: 'stemv',
+    stitchTiles: 'stitchTiles',
+    stopColor: 'stop-color',
+    stopOpacity: 'stop-opacity',
+    strikethroughPosition: 'strikethrough-position',
+    strikethroughThickness: 'strikethrough-thickness',
+    string: 'string',
+    stroke: 'stroke',
+    strokeDasharray: 'stroke-dasharray',
+    strokeDashoffset: 'stroke-dashoffset',
+    strokeLinecap: 'stroke-linecap',
+    strokeLinejoin: 'stroke-linejoin',
+    strokeMiterlimit: 'stroke-miterlimit',
+    strokeOpacity: 'stroke-opacity',
+    strokeWidth: 'stroke-width',
+    surfaceScale: 'surfaceScale',
+    systemLanguage: 'systemLanguage',
+    tableValues: 'tableValues',
+    targetX: 'targetX',
+    targetY: 'targetY',
+    textAnchor: 'text-anchor',
+    textDecoration: 'text-decoration',
+    textLength: 'textLength',
+    textRendering: 'text-rendering',
+    to: 'to',
+    transform: 'transform',
+    transformOrigin: 'transform-origin',
+    u1: 'u1',
+    u2: 'u2',
+    underlinePosition: 'underline-position',
+    underlineThickness: 'underline-thickness',
+    unicode: 'unicode',
+    unicodeBidi: 'unicode-bidi',
+    unicodeRange: 'unicode-range',
+    unitsPerEm: 'units-per-em',
+    vAlphabetic: 'v-alphabetic',
+    values: 'values',
+    vectorEffect: 'vector-effect',
+    version: 'version',
+    vertAdvY: 'vert-adv-y',
+    vertOriginX: 'vert-origin-x',
+    vertOriginY: 'vert-origin-y',
+    vHanging: 'v-hanging',
+    vIdeographic: 'v-ideographic',
+    viewBox: 'viewBox',
+    viewTarget: 'viewTarget',
+    visibility: 'visibility',
+    vMathematical: 'v-mathematical',
+    widths: 'widths',
+    wordSpacing: 'word-spacing',
+    writingMode: 'writing-mode',
+    x: 'x',
+    x1: 'x1',
+    x2: 'x2',
+    xChannelSelector: 'xChannelSelector',
+    xHeight: 'x-height',
+    xlinkActuate: 'xlink:actuate',
+    xlinkArcrole: 'xlink:arcrole',
+    xlinkHref: 'xlink:href',
+    xlinkRole: 'xlink:role',
+    xlinkShow: 'xlink:show',
+    xlinkTitle: 'xlink:title',
+    xlinkType: 'xlink:type',
+    xmlBase: 'xml:base',
+    xmlLang: 'xml:lang',
+    xmlnsXlink: 'xmlns:xlink',
+    xmlSpace: 'xml:space',
+    y: 'y',
+    y1: 'y1',
+    y2: 'y1',
+    yChannelSelector: 'yChannelSelector',
+    z: 'z',
+    zoomAndPan: 'zoomAndPan',
+};
+const list = Object.entries(idlContentMap);
+function searchIDLAttribute(name) {
+    const camelizedName = camelize(name);
+    const [idlPropName, contentAttrName] = (/^on[a-z]/.test(name) && [name.toLowerCase(), name.toLowerCase()]) ||
+        list.find(([idlPropName, contentAttrName]) => idlPropName.toLowerCase() === camelizedName.toLowerCase() ||
+            contentAttrName.toLowerCase() === name.toLowerCase() ||
+            hyphenize(idlPropName) === name.toLowerCase()) ||
+        [];
+    return {
+        idlPropName,
+        contentAttrName,
+    };
+}
+exports.searchIDLAttribute = searchIDLAttribute;
+function camelize(str) {
+    return str.replace(/[:-][a-z]/g, $0 => $0[1].toUpperCase());
+}
+function hyphenize(str) {
+    return str.replace(/[A-Z]/g, $0 => `-${$0.toLowerCase()}`);
+}

package/lib/idl-attributes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/idl-attributes.test.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const idl_attributes_1 = require("./idl-attributes");
+it('basic', () => {
+    expect((0, idl_attributes_1.searchIDLAttribute)('class')).toStrictEqual({
+        idlPropName: 'className',
+        contentAttrName: 'class',
+    });
+    expect((0, idl_attributes_1.searchIDLAttribute)('for')).toStrictEqual({
+        idlPropName: 'htmlFor',
+        contentAttrName: 'for',
+    });
+    expect((0, idl_attributes_1.searchIDLAttribute)('className')).toStrictEqual({
+        idlPropName: 'className',
+        contentAttrName: 'class',
+    });
+    expect((0, idl_attributes_1.searchIDLAttribute)('htmlFor')).toStrictEqual({
+        idlPropName: 'htmlFor',
+        contentAttrName: 'for',
+    });
+    expect((0, idl_attributes_1.searchIDLAttribute)('tabindex')).toStrictEqual({
+        idlPropName: 'tabIndex',
+        contentAttrName: 'tabindex',
+    });
+    expect((0, idl_attributes_1.searchIDLAttribute)('tab-index')).toStrictEqual({
+        idlPropName: 'tabIndex',
+        contentAttrName: 'tabindex',
+    });
+    expect((0, idl_attributes_1.searchIDLAttribute)('TabIndex')).toStrictEqual({
+        idlPropName: 'tabIndex',
+        contentAttrName: 'tabindex',
+    });
+    expect((0, idl_attributes_1.searchIDLAttribute)('x')).toStrictEqual({
+        idlPropName: 'x',
+        contentAttrName: 'x',
+    });
+    expect((0, idl_attributes_1.searchIDLAttribute)('y')).toStrictEqual({
+        idlPropName: 'y',
+        contentAttrName: 'y',
+    });
+    expect((0, idl_attributes_1.searchIDLAttribute)('attribute-name')).toStrictEqual({
+        idlPropName: 'attributeName',
+        contentAttrName: 'attributeName',
+    });
+});

package/lib/ignore-block.d.ts

@@ -1,4 +1,4 @@
-import { IgnoreBlock, IgnoreTag } from './types';
-import { MLASTNode } from '@markuplint/ml-ast';
+import type { IgnoreBlock, IgnoreTag } from './types';
+import type { MLASTNode } from '@markuplint/ml-ast';
 export declare function ignoreBlock(source: string, tags: IgnoreTag[]): IgnoreBlock;
 export declare function restoreNode(nodeList: MLASTNode[], ignoreBlock: IgnoreBlock): MLASTNode[];

package/lib/ignore-block.js

@@ -1,39 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.restoreNode = exports.ignoreBlock = void 0;
-const ml_ast_1 = require("@markuplint/ml-ast");
-const utils_1 = require("./utils");
 const const_1 = require("./const");
+const create_token_1 = require("./create-token");
+const get_location_1 = require("./get-location");
+const siblings_correction_1 = require("./siblings-correction");
 function ignoreBlock(source, tags) {
     let replaced = source;
     const stack = [];
     for (const tag of tags) {
-        const start = removeGlobalOption(tag.start);
-        const end = removeGlobalOption(tag.end);
-        while (start.test(replaced)) {
-            const [index, above, startTag, _below] = snap(replaced, start);
-            if (!startTag || !_below) {
-                continue;
-            }
-            const [, taggedCode, endTag, below] = snap(_below, end);
-            stack.push({
-                type: tag.type,
-                index,
-                startTag,
-                taggedCode,
-                endTag: endTag || null,
-            });
-            /**
-             * It will not replace line breaks because detects line number.
-             */
+        // Replace tags in attributes
+        const attr = maskText(prepend(tag.start, '(?<=(?:"|\'))'), append(tag.end, '(?=(?:"|\'))'), replaced, (startTag, taggedCode, endTag) => {
+            const mask = const_1.MASK_CHAR.repeat(startTag.length) +
+                taggedCode.replace(/[^\n]/g, const_1.MASK_CHAR) +
+                const_1.MASK_CHAR.repeat((endTag || '').length);
+            return mask;
+        });
+        replaced = attr.replaced;
+        stack.push(...attr.stack.map(res => ({ ...res, type: tag.type })));
+        // Replace tags in other nodes
+        const text = maskText(tag.start, tag.end, replaced, (startTag, taggedCode, endTag) => {
             const mask = const_1.MASK_CHAR.repeat(startTag.length) +
                 taggedCode.replace(/[^\n]/g, const_1.MASK_CHAR) +
                 const_1.MASK_CHAR.repeat((endTag || '').length);
             const taggedMask = `<!${mask.slice(2).slice(0, -1)}>`;
-            replaced = above + taggedMask + (below || '');
-        }
-        stack.sort((a, b) => a.index - b.index);
+            return taggedMask;
+        });
+        replaced = text.replaced;
+        stack.push(...text.stack.map(res => ({ ...res, type: tag.type })));
     }
+    stack.sort((a, b) => a.index - b.index);
     return {
         source,
         replaced,
@@ -41,11 +37,37 @@ function ignoreBlock(source, tags) {
     };
 }
 exports.ignoreBlock = ignoreBlock;
+function maskText(start, end, replaced, masking) {
+    const stack = [];
+    start = removeGlobalOption(start);
+    end = removeGlobalOption(end);
+    while (start.test(replaced)) {
+        const [index, above, startTag, _below] = snap(replaced, start);
+        if (!startTag || !_below) {
+            continue;
+        }
+        const [, taggedCode, endTag, below] = snap(_below, end);
+        stack.push({
+            index,
+            startTag,
+            taggedCode,
+            endTag: endTag || null,
+        });
+        /**
+         * It will not replace line breaks because detects line number.
+         */
+        replaced = above + masking(startTag, taggedCode, endTag) + (below || '');
+    }
+    return {
+        replaced,
+        stack,
+    };
+}
 function restoreNode(nodeList, ignoreBlock) {
     nodeList = nodeList.slice();
     const { source, stack } = ignoreBlock;
     for (const node of nodeList) {
-        if (node.type === ml_ast_1.MLASTNodeType.Comment) {
+        if (node.type === 'comment' || node.type === 'text') {
             if (!hasIgnoreBlock(node.raw)) {
                 continue;
             }
@@ -62,22 +84,27 @@ function restoreNode(nodeList, ignoreBlock) {
                     const below = text.slice(above.length + body.length);
                     if (above) {
                         const offset = node.startOffset + pointer;
-                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = utils_1.sliceFragment(source, offset, offset + above.length);
-                        const textNode = Object.assign(Object.assign({}, node), { uuid: utils_1.uuid(), type: ml_ast_1.MLASTNodeType.Text, raw,
+                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = (0, get_location_1.sliceFragment)(source, offset, offset + above.length);
+                        const textNode = {
+                            ...node,
+                            uuid: (0, create_token_1.uuid)(),
+                            type: 'text',
+                            raw,
                             startOffset,
                             endOffset,
                             startLine,
                             endLine,
                             startCol,
-                            endCol });
+                            endCol,
+                        };
                         insertList.push(textNode);
                     }
                     if (body) {
                         const offset = node.startOffset + pointer + above.length;
-                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = utils_1.sliceFragment(source, offset, offset + body.length);
+                        const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = (0, get_location_1.sliceFragment)(source, offset, offset + body.length);
                         const bodyNode = {
-                            uuid: utils_1.uuid(),
-                            type: ml_ast_1.MLASTNodeType.PreprocessorSpecificBlock,
+                            uuid: (0, create_token_1.uuid)(),
+                            type: 'psblock',
                             nodeName: `#ps:${tag.type}`,
                             raw,
                             parentNode: node.parentNode,
@@ -100,22 +127,40 @@ function restoreNode(nodeList, ignoreBlock) {
             }
             if (text) {
                 const offset = node.endOffset - text.length;
-                const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = utils_1.sliceFragment(source, offset, offset + text.length);
-                const textNode = Object.assign(Object.assign({}, node), { uuid: utils_1.uuid(), type: ml_ast_1.MLASTNodeType.Text, raw,
+                const { raw, startOffset, endOffset, startLine, endLine, startCol, endCol } = (0, get_location_1.sliceFragment)(source, offset, offset + text.length);
+                const textNode = {
+                    ...node,
+                    uuid: (0, create_token_1.uuid)(),
+                    type: 'text',
+                    raw,
                     startOffset,
                     endOffset,
                     startLine,
                     endLine,
                     startCol,
-                    endCol });
+                    endCol,
+                };
                 insertList.push(textNode);
             }
-            utils_1.siblingsCorrection(insertList);
+            (0, siblings_correction_1.siblingsCorrection)(insertList);
             if (parentNode) {
                 parentNode.childNodes = insertList;
             }
             nodeList.splice(index, 1, ...insertList);
         }
+        if (node.type === 'starttag') {
+            for (const attr of node.attributes) {
+                if (attr.type === 'ps-attr' || attr.value.raw === '' || !hasIgnoreBlock(attr.value.raw)) {
+                    continue;
+                }
+                for (const tag of stack) {
+                    if (attr.value.startOffset <= tag.index && tag.index < attr.value.endOffset) {
+                        attr.value.raw = tag.startTag + tag.taggedCode + tag.endTag;
+                        attr.isDynamicValue = true;
+                    }
+                }
+            }
+        }
     }
     return nodeList;
 }
@@ -134,6 +179,12 @@ function snap(str, reg) {
 function removeGlobalOption(reg) {
     return new RegExp(reg.source, reg.ignoreCase ? 'i' : '');
 }
+function prepend(reg, str) {
+    return new RegExp(str + reg.source, reg.ignoreCase ? 'i' : '');
+}
+function append(reg, str) {
+    return new RegExp(reg.source + str, reg.ignoreCase ? 'i' : '');
+}
 function hasIgnoreBlock(textContent) {
     return textContent.includes(const_1.MASK_CHAR);
 }

package/lib/ignore-front-matter.d.ts

@@ -0,0 +1 @@
+export declare function ignoreFrontMatter(code: string): string;

package/lib/ignore-front-matter.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ignoreFrontMatter = void 0;
+function ignoreFrontMatter(code) {
+    const reStart = /^(?:\s*\r?\n)?---\r?\n/.exec(code);
+    if (!reStart) {
+        return code;
+    }
+    const startPoint = reStart[0].length;
+    const afterStart = code.slice(startPoint);
+    const reEnd = /\r?\n---\r?\n/.exec(afterStart);
+    if (!reEnd) {
+        return code;
+    }
+    const endPoint = startPoint + reEnd.index + reEnd[0].length;
+    const frontMatter = code.slice(0, endPoint);
+    const afterCode = code.slice(endPoint);
+    const masked = frontMatter.replace(/[^\r\n]/g, ' ');
+    return masked + afterCode;
+}
+exports.ignoreFrontMatter = ignoreFrontMatter;

package/lib/index.d.ts

@@ -1,3 +1,8 @@
+export * from './decision';
+export * from './get-location';
+export * from './create-token';
+export * from './idl-attributes';
+export * from './walker';
 export * from './ignore-block';
-export * from './utils';
-export declare function ignoreFrontMatter(code: string): string;
+export * from './ignore-front-matter';
+export * from './debugger';