array (
  0 => 'http://www.kershawknives.com/knivesTools/images/ETUCBLK.jpg',
  1 => '/var/www/vhosts/knives.pl/subdomains/img/httpdocs/proxy/cache/c8c2ae8ff7ad243859acfb43e1ce5403be595736b97584a6382bd9bfe6286846/origin.jpg',
  2 => false,
)<br />
<b>Warning</b>:  Trying to access array offset on value of type bool in <b>/var/www/vhosts/knives.pl/subdomains/img/httpdocs/proxy/index.php</b> on line <b>182</b><br />
<!doctype html>
<html lang="en">
    <head >
        <script>
    var LOCALE = 'en\u002DUS';
    var BASE_URL = 'https\u003A\u002F\u002Fkershaw.kaiusa.com\u002F';
    var require = {
        'baseUrl': 'https\u003A\u002F\u002Fkershaw.kaiusa.com\u002Fstatic\u002Fversion1713440747\u002Ffrontend\u002FBlueAcorn\u002Fkershaw\u002Fen_US'
    };</script>        <meta charset="utf-8"/><script type="text/javascript">(window.NREUM||(NREUM={})).init={ajax:{deny_list:["bam.nr-data.net"]}};(window.NREUM||(NREUM={})).loader_config={licenseKey:"666a992a3c",applicationID:"303996656"};;/*! For license information please see nr-loader-rum-1.258.0.min.js.LICENSE.txt */
(()=>{var e,t,r={234:(e,t,r)=>{"use strict";r.d(t,{P_:()=>v,Mt:()=>b,C5:()=>s,OP:()=>k,lF:()=>P,Yu:()=>_,Dg:()=>m,CX:()=>c,GE:()=>w,sU:()=>N});var n=r(8632),i=r(9567);const o={beacon:n.ce.beacon,errorBeacon:n.ce.errorBeacon,licenseKey:void 0,applicationID:void 0,sa:void 0,queueTime:void 0,applicationTime:void 0,ttGuid:void 0,user:void 0,account:void 0,product:void 0,extra:void 0,jsAttributes:{},userAttributes:void 0,atts:void 0,transactionName:void 0,tNamePlain:void 0},a={};function s(e){if(!e)throw new Error("All info objects require an agent identifier!");if(!a[e])throw new Error("Info for ".concat(e," was never set"));return a[e]}function c(e,t){if(!e)throw new Error("All info objects require an agent identifier!");a[e]=(0,i.D)(t,o);const r=(0,n.ek)(e);r&&(r.info=a[e])}const u=e=>{if(!e||"string"!=typeof e)return!1;try{document.createDocumentFragment().querySelector(e)}catch{return!1}return!0};var d=r(7056),l=r(50);const f="[data-nr-mask]",g=()=>{const e={mask_selector:"*",block_selector:"[data-nr-block]",mask_input_options:{color:!1,date:!1,"datetime-local":!1,email:!1,month:!1,number:!1,range:!1,search:!1,tel:!1,text:!1,time:!1,url:!1,week:!1,textarea:!1,select:!1,password:!0}};return{feature_flags:[],proxy:{assets:void 0,beacon:void 0},privacy:{cookies_enabled:!0},ajax:{deny_list:void 0,block_internal:!0,enabled:!0,harvestTimeSeconds:10,autoStart:!0},distributed_tracing:{enabled:void 0,exclude_newrelic_header:void 0,cors_use_newrelic_header:void 0,cors_use_tracecontext_headers:void 0,allowed_origins:void 0},session:{expiresMs:d.oD,inactiveMs:d.Hb},ssl:void 0,obfuscate:void 0,jserrors:{enabled:!0,harvestTimeSeconds:10,autoStart:!0},metrics:{enabled:!0,autoStart:!0},page_action:{enabled:!0,harvestTimeSeconds:30,autoStart:!0},page_view_event:{enabled:!0,autoStart:!0},page_view_timing:{enabled:!0,harvestTimeSeconds:30,long_task:!1,autoStart:!0},session_trace:{enabled:!0,harvestTimeSeconds:10,autoStart:!0},harvest:{tooManyRequestsDelay:60},session_replay:{autoStart:!0,enabled:!1,harvestTimeSeconds:60,preload:!1,sampling_rate:10,error_sampling_rate:100,collect_fonts:!1,inline_images:!1,inline_stylesheet:!0,mask_all_inputs:!0,get mask_text_selector(){return e.mask_selector},set mask_text_selector(t){u(t)?e.mask_selector="".concat(t,",").concat(f):""===t||null===t?e.mask_selector=f:(0,l.Z)("An invalid session_replay.mask_selector was provided. '*' will be used.",t)},get block_class(){return"nr-block"},get ignore_class(){return"nr-ignore"},get mask_text_class(){return"nr-mask"},get block_selector(){return e.block_selector},set block_selector(t){u(t)?e.block_selector+=",".concat(t):""!==t&&(0,l.Z)("An invalid session_replay.block_selector was provided and will not be used",t)},get mask_input_options(){return e.mask_input_options},set mask_input_options(t){t&&"object"==typeof t?e.mask_input_options={...t,password:!0}:(0,l.Z)("An invalid session_replay.mask_input_option was provided and will not be used",t)}},spa:{enabled:!0,harvestTimeSeconds:10,autoStart:!0},soft_navigations:{enabled:!0,harvestTimeSeconds:10,autoStart:!0}}},p={},h="All configuration objects require an agent identifier!";function v(e){if(!e)throw new Error(h);if(!p[e])throw new Error("Configuration for ".concat(e," was never set"));return p[e]}function m(e,t){if(!e)throw new Error(h);p[e]=(0,i.D)(t,g());const r=(0,n.ek)(e);r&&(r.init=p[e])}function b(e,t){if(!e)throw new Error(h);var r=v(e);if(r){for(var n=t.split("."),i=0;i<n.length-1;i++)if("object"!=typeof(r=r[n[i]]))return;r=r[n[n.length-1]]}return r}const y={accountID:void 0,trustKey:void 0,agentID:void 0,licenseKey:void 0,applicationID:void 0,xpid:void 0},A={};function w(e,t){if(!e)throw new Error("All loader-config objects require an agent identifier!");A[e]=(0,i.D)(t,y);const r=(0,n.ek)(e);r&&(r.loader_config=A[e])}const _=(0,n.mF)().o;var E=r(385),x=r(6818);const D={buildEnv:x.Re,distMethod:x.gF,version:x.q4,originTime:E.sK},R={customTransaction:void 0,disabled:!1,isolatedBacklog:!1,loaderType:void 0,maxBytes:3e4,onerror:void 0,origin:""+E._A.location,ptid:void 0,releaseIds:{},appMetadata:{},session:void 0,denyList:void 0,harvestCount:0,timeKeeper:void 0},S={};function k(e){if(!e)throw new Error("All runtime objects require an agent identifier!");if(!S[e])throw new Error("Runtime for ".concat(e," was never set"));return S[e]}function N(e,t){if(!e)throw new Error("All runtime objects require an agent identifier!");S[e]={...(0,i.D)(t,R),...D};const r=(0,n.ek)(e);r&&(r.runtime=S[e])}function P(e){return function(e){try{const t=s(e);return!!t.licenseKey&&!!t.errorBeacon&&!!t.applicationID}catch(e){return!1}}(e)}},9567:(e,t,r)=>{"use strict";r.d(t,{D:()=>i});var n=r(50);function i(e,t){try{if(!e||"object"!=typeof e)return(0,n.Z)("Setting a Configurable requires an object as input");if(!t||"object"!=typeof t)return(0,n.Z)("Setting a Configurable requires a model to set its initial properties");const r=Object.create(Object.getPrototypeOf(t),Object.getOwnPropertyDescriptors(t)),o=0===Object.keys(r).length?e:r;for(let a in o)if(void 0!==e[a])try{if(null===e[a]){r[a]=null;continue}Array.isArray(e[a])&&Array.isArray(t[a])?r[a]=Array.from(new Set([...e[a],...t[a]])):"object"==typeof e[a]&&"object"==typeof t[a]?r[a]=i(e[a],t[a]):r[a]=e[a]}catch(e){(0,n.Z)("An error occurred while setting a property of a Configurable",e)}return r}catch(e){(0,n.Z)("An error occured while setting a Configurable",e)}}},6818:(e,t,r)=>{"use strict";r.d(t,{Re:()=>i,gF:()=>o,q4:()=>n});const n="1.258.0",i="PROD",o="CDN"},385:(e,t,r)=>{"use strict";r.d(t,{Nk:()=>d,Tt:()=>s,_A:()=>o,iS:()=>a,il:()=>n,sK:()=>l,ux:()=>c,v6:()=>i,w1:()=>u});const n="undefined"!=typeof window&&!!window.document,i="undefined"!=typeof WorkerGlobalScope&&("undefined"!=typeof self&&self instanceof WorkerGlobalScope&&self.navigator instanceof WorkerNavigator||"undefined"!=typeof globalThis&&globalThis instanceof WorkerGlobalScope&&globalThis.navigator instanceof WorkerNavigator),o=n?window:"undefined"!=typeof WorkerGlobalScope&&("undefined"!=typeof self&&self instanceof WorkerGlobalScope&&self||"undefined"!=typeof globalThis&&globalThis instanceof WorkerGlobalScope&&globalThis),a=Boolean("hidden"===o?.document?.visibilityState),s=/iPad|iPhone|iPod/.test(o.navigator?.userAgent),c=s&&"undefined"==typeof SharedWorker,u=((()=>{const e=o.navigator?.userAgent?.match(/Firefox[/\s](\d+\.\d+)/);Array.isArray(e)&&e.length>=2&&e[1]})(),Boolean(n&&window.document.documentMode)),d=!!o.navigator?.sendBeacon,l=Math.floor(Date.now()-performance.now())},1117:(e,t,r)=>{"use strict";r.d(t,{w:()=>o});var n=r(50);const i={agentIdentifier:"",ee:void 0};class o{constructor(e){try{if("object"!=typeof e)return(0,n.Z)("shared context requires an object as input");this.sharedContext={},Object.assign(this.sharedContext,i),Object.entries(e).forEach((e=>{let[t,r]=e;Object.keys(i).includes(t)&&(this.sharedContext[t]=r)}))}catch(e){(0,n.Z)("An error occurred while setting SharedContext",e)}}}},8e3:(e,t,r)=>{"use strict";r.d(t,{LP:()=>l,RP:()=>c,o5:()=>u});var n=r(8325),i=r(1284),o=r(4322),a=r(3325);const s={};function c(e,t){const r={staged:!1,priority:a.p[t]||0};d(e),s[e].get(t)||s[e].set(t,r)}function u(e,t){d(e),s[e].get(t)&&s[e].delete(t),s[e].size&&f(e)}function d(e){if(!e)throw new Error("agentIdentifier required");s[e]||(s[e]=new Map)}function l(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:"",t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:"feature",r=arguments.length>2&&void 0!==arguments[2]&&arguments[2];if(d(e),!e||!s[e].get(t)||r)return g(e,t);s[e].get(t).staged=!0,f(e)}function f(e){const t=[...s[e]];t.every((e=>{let[t,r]=e;return r.staged}))&&(t.sort(((e,t)=>e[1].priority-t[1].priority)),t.forEach((t=>{let[r]=t;s[e].delete(r),g(e,r)})))}function g(e,t){const r=e?n.ee.get(e):n.ee,a=o.X.handlers;if(r.backlog&&a){var s=r.backlog[t],c=a[t];if(c){for(var u=0;s&&u<s.length;++u)p(s[u],c);(0,i.D)(c,(function(e,t){(0,i.D)(t,(function(t,r){r[0].on(e,r[1])}))}))}r.isolatedBacklog||delete a[t],r.backlog[t]=null,r.emit("drain-"+t,[])}}function p(e,t){var r=e[1];(0,i.D)(t[r],(function(t,r){var n=e[0];if(r[0]===n){var i=r[1],o=e[3],a=e[2];i.apply(o,a)}}))}},8325:(e,t,r)=>{"use strict";r.d(t,{A:()=>c,ee:()=>u});var n=r(8632),i=r(2210),o=r(234);class a{constructor(e){this.contextId=e}}var s=r(3117);const c="nr@context:".concat(s.a),u=function e(t,r){var n={},s={},d={},l=!1;try{l=16===r.length&&(0,o.OP)(r).isolatedBacklog}catch(e){}var f={on:p,addEventListener:p,removeEventListener:function(e,t){var r=n[e];if(!r)return;for(var i=0;i<r.length;i++)r[i]===t&&r.splice(i,1)},emit:function(e,r,n,i,o){!1!==o&&(o=!0);if(u.aborted&&!i)return;t&&o&&t.emit(e,r,n);for(var a=g(n),c=h(e),d=c.length,l=0;l<d;l++)c[l].apply(a,r);var p=m()[s[e]];p&&p.push([f,e,r,a]);return a},get:v,listeners:h,context:g,buffer:function(e,t){const r=m();if(t=t||"feature",f.aborted)return;Object.entries(e||{}).forEach((e=>{let[n,i]=e;s[i]=t,t in r||(r[t]=[])}))},abort:function(){f._aborted=!0,Object.keys(f.backlog).forEach((e=>{delete f.backlog[e]}))},isBuffering:function(e){return!!m()[s[e]]},debugId:r,backlog:l?{}:t&&"object"==typeof t.backlog?t.backlog:{},isolatedBacklog:l};return Object.defineProperty(f,"aborted",{get:()=>{let e=f._aborted||!1;return e||(t&&(e=t.aborted),e)}}),f;function g(e){return e&&e instanceof a?e:e?(0,i.X)(e,c,(()=>new a(c))):new a(c)}function p(e,t){n[e]=h(e).concat(t)}function h(e){return n[e]||[]}function v(t){return d[t]=d[t]||e(f,t)}function m(){return f.backlog}}(void 0,"globalEE"),d=(0,n.fP)();d.ee||(d.ee=u)},5546:(e,t,r)=>{"use strict";r.d(t,{E:()=>n,p:()=>i});var n=r(8325).ee.get("handle");function i(e,t,r,i,o){o?(o.buffer([e],i),o.emit(e,t,r)):(n.buffer([e],i),n.emit(e,t,r))}},4322:(e,t,r)=>{"use strict";r.d(t,{X:()=>o});var n=r(5546);o.on=a;var i=o.handlers={};function o(e,t,r,o){a(o||n.E,i,e,t,r)}function a(e,t,r,i,o){o||(o="feature"),e||(e=n.E);var a=t[o]=t[o]||{};(a[r]=a[r]||[]).push([e,i])}},3239:(e,t,r)=>{"use strict";r.d(t,{bP:()=>s,iz:()=>c,m$:()=>a});var n=r(385);let i=!1,o=!1;try{const e={get passive(){return i=!0,!1},get signal(){return o=!0,!1}};n._A.addEventListener("test",null,e),n._A.removeEventListener("test",null,e)}catch(e){}function a(e,t){return i||o?{capture:!!e,passive:i,signal:t}:!!e}function s(e,t){let r=arguments.length>2&&void 0!==arguments[2]&&arguments[2],n=arguments.length>3?arguments[3]:void 0;window.addEventListener(e,t,a(r,n))}function c(e,t){let r=arguments.length>2&&void 0!==arguments[2]&&arguments[2],n=arguments.length>3?arguments[3]:void 0;document.addEventListener(e,t,a(r,n))}},3117:(e,t,r)=>{"use strict";r.d(t,{a:()=>n});const n=(0,r(4402).Rl)()},4402:(e,t,r)=>{"use strict";r.d(t,{Rl:()=>a,ky:()=>s});var n=r(385);const i="xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx";function o(e,t){return e?15&e[t]:16*Math.random()|0}function a(){const e=n._A?.crypto||n._A?.msCrypto;let t,r=0;return e&&e.getRandomValues&&(t=e.getRandomValues(new Uint8Array(30))),i.split("").map((e=>"x"===e?o(t,r++).toString(16):"y"===e?(3&o()|8).toString(16):e)).join("")}function s(e){const t=n._A?.crypto||n._A?.msCrypto;let r,i=0;t&&t.getRandomValues&&(r=t.getRandomValues(new Uint8Array(e)));const a=[];for(var s=0;s<e;s++)a.push(o(r,i++).toString(16));return a.join("")}},7056:(e,t,r)=>{"use strict";r.d(t,{Bq:()=>n,Hb:()=>a,IK:()=>u,K4:()=>i,oD:()=>o,uT:()=>c,wO:()=>s});const n="NRBA",i="SESSION",o=144e5,a=18e5,s={STARTED:"session-started",PAUSE:"session-pause",RESET:"session-reset",RESUME:"session-resume",UPDATE:"session-update"},c={SAME_TAB:"same-tab",CROSS_TAB:"cross-tab"},u={OFF:0,FULL:1,ERROR:2}},7894:(e,t,r)=>{"use strict";function n(){return Math.floor(performance.now())}r.d(t,{z:()=>n})},50:(e,t,r)=>{"use strict";function n(e,t){"function"==typeof console.warn&&(console.warn("New Relic: ".concat(e)),t&&console.warn(t))}r.d(t,{Z:()=>n})},2825:(e,t,r)=>{"use strict";r.d(t,{N:()=>c,T:()=>s});var n=r(8325),i=r(385);const o="newrelic";const a=new Set,s={};function c(e,t){const r=n.ee.get(t);s[t]??={},e&&"object"==typeof e&&(a.has(t)||(r.emit("rumresp",[e]),s[t]=e,a.add(t),function(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};try{i._A.dispatchEvent(new CustomEvent(o,{detail:e}))}catch(e){}}({loaded:!0})))}},2210:(e,t,r)=>{"use strict";r.d(t,{X:()=>i});var n=Object.prototype.hasOwnProperty;function i(e,t,r){if(n.call(e,t))return e[t];var i=r();if(Object.defineProperty&&Object.keys)try{return Object.defineProperty(e,t,{value:i,writable:!0,enumerable:!1}),i}catch(e){}return e[t]=i,i}},7872:(e,t,r)=>{"use strict";function n(e){var t=this;let r=arguments.length>1&&void 0!==arguments[1]?arguments[1]:500,n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};const i=n?.leading||!1;let o;return function(){for(var n=arguments.length,a=new Array(n),s=0;s<n;s++)a[s]=arguments[s];i&&void 0===o&&(e.apply(t,a),o=setTimeout((()=>{o=clearTimeout(o)}),r)),i||(clearTimeout(o),o=setTimeout((()=>{e.apply(t,a)}),r))}}function i(e){var t=this;let r=!1;return function(){if(!r){r=!0;for(var n=arguments.length,i=new Array(n),o=0;o<n;o++)i[o]=arguments[o];e.apply(t,i)}}}r.d(t,{D:()=>n,Z:()=>i})},1284:(e,t,r)=>{"use strict";r.d(t,{D:()=>n});const n=(e,t)=>Object.entries(e||{}).map((e=>{let[r,n]=e;return t(r,n)}))},4351:(e,t,r)=>{"use strict";r.d(t,{P:()=>o});var n=r(8325);const i=()=>{const e=new WeakSet;return(t,r)=>{if("object"==typeof r&&null!==r){if(e.has(r))return;e.add(r)}return r}};function o(e){try{return JSON.stringify(e,i())}catch(e){try{n.ee.emit("internal-error",[e])}catch(e){}}}},3960:(e,t,r)=>{"use strict";r.d(t,{KB:()=>a,b2:()=>o});var n=r(3239);function i(){return"undefined"==typeof document||"complete"===document.readyState}function o(e,t){if(i())return e();(0,n.bP)("load",e,t)}function a(e){if(i())return e();(0,n.iz)("DOMContentLoaded",e)}},8632:(e,t,r)=>{"use strict";r.d(t,{EZ:()=>d,ce:()=>o,ek:()=>u,fP:()=>a,gG:()=>l,h5:()=>c,mF:()=>s});var n=r(385),i=r(7894);const o={beacon:"bam.nr-data.net",errorBeacon:"bam.nr-data.net"};function a(){return n._A.NREUM||(n._A.NREUM={}),void 0===n._A.newrelic&&(n._A.newrelic=n._A.NREUM),n._A.NREUM}function s(){let e=a();return e.o||(e.o={ST:n._A.setTimeout,SI:n._A.setImmediate,CT:n._A.clearTimeout,XHR:n._A.XMLHttpRequest,REQ:n._A.Request,EV:n._A.Event,PR:n._A.Promise,MO:n._A.MutationObserver,FETCH:n._A.fetch}),e}function c(e,t){let r=a();r.initializedAgents??={},t.initializedAt={ms:(0,i.z)(),date:new Date},r.initializedAgents[e]=t}function u(e){let t=a();return t.initializedAgents?.[e]}function d(e,t){a()[e]=t}function l(){return function(){let e=a();const t=e.info||{};e.info={beacon:o.beacon,errorBeacon:o.errorBeacon,...t}}(),function(){let e=a();const t=e.init||{};e.init={...t}}(),s(),function(){let e=a();const t=e.loader_config||{};e.loader_config={...t}}(),a()}},7956:(e,t,r)=>{"use strict";r.d(t,{N:()=>i});var n=r(3239);function i(e){let t=arguments.length>1&&void 0!==arguments[1]&&arguments[1],r=arguments.length>2?arguments[2]:void 0,i=arguments.length>3?arguments[3]:void 0;(0,n.iz)("visibilitychange",(function(){if(t)return void("hidden"===document.visibilityState&&e());e(document.visibilityState)}),r,i)}},3081:(e,t,r)=>{"use strict";r.d(t,{gF:()=>o,mY:()=>i,t9:()=>n,vz:()=>s,xS:()=>a});const n=r(3325).D.metrics,i="sm",o="cm",a="storeSupportabilityMetrics",s="storeEventMetrics"},7633:(e,t,r)=>{"use strict";r.d(t,{t:()=>n});const n=r(3325).D.pageViewEvent},9251:(e,t,r)=>{"use strict";r.d(t,{t:()=>n});const n=r(3325).D.pageViewTiming},7144:(e,t,r)=>{"use strict";r.d(t,{Ef:()=>i});var n=r(7056);r(3325).D.sessionReplay;const i={RECORD:"recordReplay",PAUSE:"pauseReplay",REPLAY_RUNNING:"replayRunning",ERROR_DURING_REPLAY:"errorDuringReplay"};n.IK.ERROR,n.IK.FULL,n.IK.OFF},5938:(e,t,r)=>{"use strict";r.d(t,{W:()=>i});var n=r(8325);class i{constructor(e,t,r){this.agentIdentifier=e,this.aggregator=t,this.ee=n.ee.get(e),this.featureName=r,this.blocked=!1}}},2758:(e,t,r)=>{"use strict";r.d(t,{j:()=>E});var n=r(3325),i=r(234),o=r(5546),a=r(8325),s=r(8e3),c=r(3960),u=r(385),d=r(50),l=r(3081),f=r(8632),g=r(7144);const p=["setErrorHandler","finished","addToTrace","addRelease","addPageAction","setCurrentRouteName","setPageViewName","setCustomAttribute","interaction","noticeError","setUserId","setApplicationVersion","start","recordReplay","pauseReplay",g.Ef.RECORD,g.Ef.PAUSE],h=["setErrorHandler","finished","addToTrace","addRelease"];var v=r(7894),m=r(7056);function b(){const e=(0,f.gG)();p.forEach((t=>{e[t]=function(){for(var r=arguments.length,n=new Array(r),i=0;i<r;i++)n[i]=arguments[i];return function(t){for(var r=arguments.length,n=new Array(r>1?r-1:0),i=1;i<r;i++)n[i-1]=arguments[i];let o=[];return Object.values(e.initializedAgents).forEach((e=>{e.exposed&&e.api[t]&&o.push(e.api[t](...n))})),o.length>1?o:o[0]}(t,...n)}}))}const y={};var A=r(2825);const w=e=>{const t=e.startsWith("http");e+="/",r.p=t?e:"https://"+e};let _=!1;function E(e){let t=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},p=arguments.length>2?arguments[2]:void 0,E=arguments.length>3?arguments[3]:void 0,{init:x,info:D,loader_config:R,runtime:S={loaderType:p},exposed:k=!0}=t;const N=(0,f.gG)();D||(x=N.init,D=N.info,R=N.loader_config),(0,i.Dg)(e.agentIdentifier,x||{}),(0,i.GE)(e.agentIdentifier,R||{}),D.jsAttributes??={},u.v6&&(D.jsAttributes.isWorker=!0),(0,i.CX)(e.agentIdentifier,D);const P=(0,i.P_)(e.agentIdentifier),j=[D.beacon,D.errorBeacon];_||(P.proxy.assets&&(w(P.proxy.assets),j.push(P.proxy.assets)),P.proxy.beacon&&j.push(P.proxy.beacon),b(),(0,f.EZ)("activatedFeatures",A.T),e.runSoftNavOverSpa&&=!0===P.soft_navigations.enabled&&P.feature_flags.includes("soft_nav")),S.denyList=[...P.ajax.deny_list||[],...P.ajax.block_internal?j:[]],(0,i.sU)(e.agentIdentifier,S),void 0===e.api&&(e.api=function(e,t){let f=arguments.length>2&&void 0!==arguments[2]&&arguments[2];t||(0,s.RP)(e,"api");const p={};var b=a.ee.get(e),A=b.get("tracer");y[e]=m.IK.OFF,b.on(g.Ef.REPLAY_RUNNING,(t=>{y[e]=t}));var w="api-",_=w+"ixn-";function E(t,r,n,o){const a=(0,i.C5)(e);return null===r?delete a.jsAttributes[t]:(0,i.CX)(e,{...a,jsAttributes:{...a.jsAttributes,[t]:r}}),R(w,n,!0,o||null===r?"session":void 0)(t,r)}function x(){}h.forEach((e=>{p[e]=R(w,e,!0,"api")})),p.addPageAction=R(w,"addPageAction",!0,n.D.pageAction),p.setPageViewName=function(t,r){if("string"==typeof t)return"/"!==t.charAt(0)&&(t="/"+t),(0,i.OP)(e).customTransaction=(r||"http://custom.transaction")+t,R(w,"setPageViewName",!0)()},p.setCustomAttribute=function(e,t){let r=arguments.length>2&&void 0!==arguments[2]&&arguments[2];if("string"==typeof e){if(["string","number","boolean"].includes(typeof t)||null===t)return E(e,t,"setCustomAttribute",r);(0,d.Z)("Failed to execute setCustomAttribute.\nNon-null value must be a string, number or boolean type, but a type of <".concat(typeof t,"> was provided."))}else(0,d.Z)("Failed to execute setCustomAttribute.\nName must be a string type, but a type of <".concat(typeof e,"> was provided."))},p.setUserId=function(e){if("string"==typeof e||null===e)return E("enduser.id",e,"setUserId",!0);(0,d.Z)("Failed to execute setUserId.\nNon-null value must be a string type, but a type of <".concat(typeof e,"> was provided."))},p.setApplicationVersion=function(e){if("string"==typeof e||null===e)return E("application.version",e,"setApplicationVersion",!1);(0,d.Z)("Failed to execute setApplicationVersion. Expected <String | null>, but got <".concat(typeof e,">."))},p.start=e=>{try{const t=e?"defined":"undefined";(0,o.p)(l.xS,["API/start/".concat(t,"/called")],void 0,n.D.metrics,b);const r=Object.values(n.D);if(void 0===e)e=r;else{if((e=Array.isArray(e)&&e.length?e:[e]).some((e=>!r.includes(e))))return(0,d.Z)("Invalid feature name supplied. Acceptable feature names are: ".concat(r));e.includes(n.D.pageViewEvent)||e.push(n.D.pageViewEvent)}e.forEach((e=>{b.emit("".concat(e,"-opt-in"))}))}catch(e){(0,d.Z)("An unexpected issue occurred",e)}},p[g.Ef.RECORD]=function(){(0,o.p)(l.xS,["API/recordReplay/called"],void 0,n.D.metrics,b),(0,o.p)(g.Ef.RECORD,[],void 0,n.D.sessionReplay,b)},p[g.Ef.PAUSE]=function(){(0,o.p)(l.xS,["API/pauseReplay/called"],void 0,n.D.metrics,b),(0,o.p)(g.Ef.PAUSE,[],void 0,n.D.sessionReplay,b)},p.interaction=function(e){return(new x).get("object"==typeof e?e:{})};const D=x.prototype={createTracer:function(e,t){var r={},i=this,a="function"==typeof t;return(0,o.p)(l.xS,["API/createTracer/called"],void 0,n.D.metrics,b),f||(0,o.p)(_+"tracer",[(0,v.z)(),e,r],i,n.D.spa,b),function(){if(A.emit((a?"":"no-")+"fn-start",[(0,v.z)(),i,a],r),a)try{return t.apply(this,arguments)}catch(e){throw A.emit("fn-err",[arguments,this,e],r),e}finally{A.emit("fn-end",[(0,v.z)()],r)}}}};function R(e,t,r,i){return function(){return(0,o.p)(l.xS,["API/"+t+"/called"],void 0,n.D.metrics,b),i&&(0,o.p)(e+t,[(0,v.z)(),...arguments],r?null:this,i,b),r?void 0:this}}function S(){r.e(75).then(r.bind(r,7438)).then((t=>{let{setAPI:r}=t;r(e),(0,s.LP)(e,"api")})).catch((()=>{(0,d.Z)("Downloading runtime APIs failed..."),b.abort()}))}return["actionText","setName","setAttribute","save","ignore","onEnd","getContext","end","get"].forEach((e=>{D[e]=R(_,e,void 0,f?n.D.softNav:n.D.spa)})),p.setCurrentRouteName=f?R(_,"routeName",void 0,n.D.softNav):R(w,"routeName",!0,n.D.spa),p.noticeError=function(t,r){"string"==typeof t&&(t=new Error(t)),(0,o.p)(l.xS,["API/noticeError/called"],void 0,n.D.metrics,b),(0,o.p)("err",[t,(0,v.z)(),!1,r,!!y[e]],void 0,n.D.jserrors,b)},u.il?(0,c.b2)((()=>S()),!0):S(),p}(e.agentIdentifier,E,e.runSoftNavOverSpa)),void 0===e.exposed&&(e.exposed=k),_=!0}},8993:(e,t,r)=>{r.nc=(()=>{try{return document?.currentScript?.nonce}catch(e){}return""})()},3325:(e,t,r)=>{"use strict";r.d(t,{D:()=>n,p:()=>i});const n={ajax:"ajax",jserrors:"jserrors",metrics:"metrics",pageAction:"page_action",pageViewEvent:"page_view_event",pageViewTiming:"page_view_timing",sessionReplay:"session_replay",sessionTrace:"session_trace",softNav:"soft_navigations",spa:"spa"},i={[n.pageViewEvent]:1,[n.pageViewTiming]:2,[n.metrics]:3,[n.jserrors]:4,[n.ajax]:5,[n.sessionTrace]:6,[n.pageAction]:7,[n.spa]:8,[n.softNav]:9,[n.sessionReplay]:10}}},n={};function i(e){var t=n[e];if(void 0!==t)return t.exports;var o=n[e]={exports:{}};return r[e](o,o.exports,i),o.exports}i.m=r,i.d=(e,t)=>{for(var r in t)i.o(t,r)&&!i.o(e,r)&&Object.defineProperty(e,r,{enumerable:!0,get:t[r]})},i.f={},i.e=e=>Promise.all(Object.keys(i.f).reduce(((t,r)=>(i.f[r](e,t),t)),[])),i.u=e=>"nr-rum-1.258.0.min.js",i.o=(e,t)=>Object.prototype.hasOwnProperty.call(e,t),e={},t="NRBA-1.258.0.PROD:",i.l=(r,n,o,a)=>{if(e[r])e[r].push(n);else{var s,c;if(void 0!==o)for(var u=document.getElementsByTagName("script"),d=0;d<u.length;d++){var l=u[d];if(l.getAttribute("src")==r||l.getAttribute("data-webpack")==t+o){s=l;break}}if(!s){c=!0;var f={75:"sha512-dbRQ0U/DzQ6bR/LVo1bSCjmtT4Mn+TUoByqFctqWrjwdLoHvi/Uhr3w190Zk5FuNMJFjPV0z6jQVNhQGb0DrLQ=="};(s=document.createElement("script")).charset="utf-8",s.timeout=120,i.nc&&s.setAttribute("nonce",i.nc),s.setAttribute("data-webpack",t+o),s.src=r,0!==s.src.indexOf(window.location.origin+"/")&&(s.crossOrigin="anonymous"),f[a]&&(s.integrity=f[a])}e[r]=[n];var g=(t,n)=>{s.onerror=s.onload=null,clearTimeout(p);var i=e[r];if(delete e[r],s.parentNode&&s.parentNode.removeChild(s),i&&i.forEach((e=>e(n))),t)return t(n)},p=setTimeout(g.bind(null,void 0,{type:"timeout",target:s}),12e4);s.onerror=g.bind(null,s.onerror),s.onload=g.bind(null,s.onload),c&&document.head.appendChild(s)}},i.r=e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})},i.p="https://js-agent.newrelic.com/",(()=>{var e={50:0,832:0};i.f.j=(t,r)=>{var n=i.o(e,t)?e[t]:void 0;if(0!==n)if(n)r.push(n[2]);else{var o=new Promise(((r,i)=>n=e[t]=[r,i]));r.push(n[2]=o);var a=i.p+i.u(t),s=new Error;i.l(a,(r=>{if(i.o(e,t)&&(0!==(n=e[t])&&(e[t]=void 0),n)){var o=r&&("load"===r.type?"missing":r.type),a=r&&r.target&&r.target.src;s.message="Loading chunk "+t+" failed.\n("+o+": "+a+")",s.name="ChunkLoadError",s.type=o,s.request=a,n[1](s)}}),"chunk-"+t,t)}};var t=(t,r)=>{var n,o,[a,s,c]=r,u=0;if(a.some((t=>0!==e[t]))){for(n in s)i.o(s,n)&&(i.m[n]=s[n]);if(c)c(i)}for(t&&t(r);u<a.length;u++)o=a[u],i.o(e,o)&&e[o]&&e[o][0](),e[o]=0},r=self["webpackChunk:NRBA-1.258.0.PROD"]=self["webpackChunk:NRBA-1.258.0.PROD"]||[];r.forEach(t.bind(null,0)),r.push=t.bind(null,r.push.bind(r))})(),(()=>{"use strict";i(8993);var e=i(50),t=i(7144),r=i(4402);class n{agentIdentifier;constructor(){let e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:(0,r.ky)(16);this.agentIdentifier=e}#e(t){for(var r=arguments.length,n=new Array(r>1?r-1:0),i=1;i<r;i++)n[i-1]=arguments[i];if("function"==typeof this.api?.[t])return this.api[t](...n);(0,e.Z)("Call to agent api ".concat(t," failed. The API is not currently initialized."))}addPageAction(e,t){return this.#e("addPageAction",e,t)}setPageViewName(e,t){return this.#e("setPageViewName",e,t)}setCustomAttribute(e,t,r){return this.#e("setCustomAttribute",e,t,r)}noticeError(e,t){return this.#e("noticeError",e,t)}setUserId(e){return this.#e("setUserId",e)}setApplicationVersion(e){return this.#e("setApplicationVersion",e)}setErrorHandler(e){return this.#e("setErrorHandler",e)}finished(e){return this.#e("finished",e)}addRelease(e,t){return this.#e("addRelease",e,t)}start(e){return this.#e("start",e)}recordReplay(){return this.#e(t.Ef.RECORD)}pauseReplay(){return this.#e(t.Ef.PAUSE)}addToTrace(e){return this.#e("addToTrace",e)}setCurrentRouteName(e){return this.#e("setCurrentRouteName",e)}interaction(){return this.#e("interaction")}}var o=i(3325),a=i(234);const s=Object.values(o.D);function c(e){const t={};return s.forEach((r=>{t[r]=function(e,t){return!0===(0,a.Mt)(t,"".concat(e,".enabled"))}(r,e)})),t}var u=i(2758);var d=i(8e3),l=i(5938),f=i(3960),g=i(385);function p(e){return g.il&&!0===(0,a.Mt)(e,"privacy.cookies_enabled")}function h(e){return!!a.Yu.MO&&p(e)&&!0===(0,a.Mt)(e,"session_trace.enabled")}var v=i(7872);class m extends l.W{constructor(e,t,r){let n=!(arguments.length>3&&void 0!==arguments[3])||arguments[3];super(e,t,r),this.auto=n,this.abortHandler=void 0,this.featAggregate=void 0,this.onAggregateImported=void 0,!1===(0,a.Mt)(this.agentIdentifier,"".concat(this.featureName,".autoStart"))&&(this.auto=!1),this.auto?(0,d.RP)(e,r):this.ee.on("".concat(this.featureName,"-opt-in"),(0,v.Z)((()=>{(0,d.RP)(this.agentIdentifier,this.featureName),this.auto=!0,this.importAggregator()})))}importAggregator(){let t,r=arguments.length>0&&void 0!==arguments[0]?arguments[0]:{};if(this.featAggregate||!this.auto)return;this.onAggregateImported=new Promise((e=>{t=e}));const n=async()=>{let n;try{if(p(this.agentIdentifier)){const{setupAgentSession:e}=await i.e(75).then(i.bind(i,7920));n=e(this.agentIdentifier)}}catch(t){(0,e.Z)("A problem occurred when starting up session manager. This page will not start or extend any session.",t),this.featureName===o.D.sessionReplay&&this.abortHandler?.()}try{if(!this.#t(this.featureName,n))return(0,d.LP)(this.agentIdentifier,this.featureName),void t(!1);const{lazyFeatureLoader:e}=await i.e(75).then(i.bind(i,8582)),{Aggregate:o}=await e(this.featureName,"aggregate");this.featAggregate=new o(this.agentIdentifier,this.aggregator,r),t(!0)}catch(r){(0,e.Z)("Downloading and initializing ".concat(this.featureName," failed..."),r),this.abortHandler?.(),(0,d.LP)(this.agentIdentifier,this.featureName,!0),t(!1),this.ee&&this.ee.abort()}};g.il?(0,f.b2)((()=>n()),!0):n()}#t(e,t){return e!==o.D.sessionReplay||(r=this.agentIdentifier,n=t,!(!h(r)||!n?.isNew&&!n?.state.sessionReplayMode));var r,n}}var b=i(7633);class y extends m{static featureName=b.t;constructor(e,t){let r=!(arguments.length>2&&void 0!==arguments[2])||arguments[2];super(e,t,b.t,r),this.importAggregator()}}var A=i(1117),w=i(1284);class _ extends A.w{constructor(e){super(e),this.aggregatedData={}}store(e,t,r,n,i){var o=this.getBucket(e,t,r,i);return o.metrics=function(e,t){t||(t={count:0});return t.count+=1,(0,w.D)(e,(function(e,r){t[e]=E(r,t[e])})),t}(n,o.metrics),o}merge(e,t,r,n,i){var o=this.getBucket(e,t,n,i);if(o.metrics){var a=o.metrics;a.count+=r.count,(0,w.D)(r,(function(e,t){if("count"!==e){var n=a[e],i=r[e];i&&!i.c?a[e]=E(i.t,n):a[e]=function(e,t){if(!t)return e;t.c||(t=x(t.t));return t.min=Math.min(e.min,t.min),t.max=Math.max(e.max,t.max),t.t+=e.t,t.sos+=e.sos,t.c+=e.c,t}(i,a[e])}}))}else o.metrics=r}storeMetric(e,t,r,n){var i=this.getBucket(e,t,r);return i.stats=E(n,i.stats),i}getBucket(e,t,r,n){this.aggregatedData[e]||(this.aggregatedData[e]={});var i=this.aggregatedData[e][t];return i||(i=this.aggregatedData[e][t]={params:r||{}},n&&(i.custom=n)),i}get(e,t){return t?this.aggregatedData[e]&&this.aggregatedData[e][t]:this.aggregatedData[e]}take(e){for(var t={},r="",n=!1,i=0;i<e.length;i++)t[r=e[i]]=Object.values(this.aggregatedData[r]||{}),t[r].length&&(n=!0),delete this.aggregatedData[r];return n?t:null}}function E(e,t){return null==e?function(e){e?e.c++:e={c:1};return e}(t):t?(t.c||(t=x(t.t)),t.c+=1,t.t+=e,t.sos+=e*e,e>t.max&&(t.max=e),e<t.min&&(t.min=e),t):{t:e}}function x(e){return{t:e,min:e,max:e,sos:e*e,c:1}}var D=i(8632),R=i(4351);var S=i(5546),k=i(7956),N=i(3239),P=i(9251),j=i(7894);class T extends m{static featureName=P.t;constructor(e,t){let r=!(arguments.length>2&&void 0!==arguments[2])||arguments[2];super(e,t,P.t,r),g.il&&((0,k.N)((()=>(0,S.p)("docHidden",[(0,j.z)()],void 0,P.t,this.ee)),!0),(0,N.bP)("pagehide",(()=>(0,S.p)("winPagehide",[(0,j.z)()],void 0,P.t,this.ee))),this.importAggregator())}}var I=i(3081);class O extends m{static featureName=I.t9;constructor(e,t){let r=!(arguments.length>2&&void 0!==arguments[2])||arguments[2];super(e,t,I.t9,r),this.importAggregator()}}new class extends n{constructor(t,r){super(r),g._A?(this.sharedAggregator=new _({agentIdentifier:this.agentIdentifier}),this.features={},(0,D.h5)(this.agentIdentifier,this),this.desiredFeatures=new Set(t.features||[]),this.desiredFeatures.add(y),this.runSoftNavOverSpa=[...this.desiredFeatures].some((e=>e.featureName===o.D.softNav)),(0,u.j)(this,t,t.loaderType||"agent"),this.run()):(0,e.Z)("Failed to initialize the agent. Could not determine the runtime environment.")}get config(){return{info:this.info,init:this.init,loader_config:this.loader_config,runtime:this.runtime}}run(){try{const t=c(this.agentIdentifier),r=[...this.desiredFeatures];r.sort(((e,t)=>o.p[e.featureName]-o.p[t.featureName])),r.forEach((r=>{if(!t[r.featureName]&&r.featureName!==o.D.pageViewEvent)return;if(this.runSoftNavOverSpa&&r.featureName===o.D.spa)return;if(!this.runSoftNavOverSpa&&r.featureName===o.D.softNav)return;const n=function(e){switch(e){case o.D.ajax:return[o.D.jserrors];case o.D.sessionTrace:return[o.D.ajax,o.D.pageViewEvent];case o.D.sessionReplay:return[o.D.sessionTrace];case o.D.pageViewTiming:return[o.D.pageViewEvent];default:return[]}}(r.featureName);n.every((e=>e in this.features))||(0,e.Z)("".concat(r.featureName," is enabled but one or more dependent features has not been initialized (").concat((0,R.P)(n),"). This may cause unintended consequences or missing data...")),this.features[r.featureName]=new r(this.agentIdentifier,this.sharedAggregator)}))}catch(t){(0,e.Z)("Failed to initialize all enabled instrument classes (agent aborted) -",t);for(const e in this.features)this.features[e].abortHandler?.();const r=(0,D.fP)();delete r.initializedAgents[this.agentIdentifier]?.api,delete r.initializedAgents[this.agentIdentifier]?.features,delete this.sharedAggregator;return r.ee.get(this.agentIdentifier).abort(),!1}}}({features:[y,T,O],loaderType:"lite"})})()})();</script>
<meta name="title" content="Next Level Pocketknives | Kershaw Knives"/>
<meta name="description" content="Get innovative technologies, top style, and quality materials. Wide range of pocketknives for everyday carrying, camping, hiking, hunting, work, and more."/>
<meta name="robots" content="INDEX,FOLLOW"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<meta name="format-detection" content="telephone=no"/>
<title>Next Level Pocketknives | Kershaw Knives</title>
<link  rel="stylesheet" type="text/css"  media="all" href="https://kershaw.kaiusa.com/static/version1713440747/_cache/merged/f9f0ee9785d8f87a812795a65c76fd4e.min.css" />
<link  rel="stylesheet" type="text/css"  media="screen and (min-width: 768px)" href="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/css/styles-l.min.css" />
<link  rel="stylesheet" type="text/css"  media="print" href="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/css/print.min.css" />
<script  type="text/javascript"  src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/requirejs/require.js"></script>
<script  type="text/javascript"  src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/Magento_QuickCheckout/js/disabled.js"></script>
<script  type="text/javascript"  src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/mage/requirejs/mixins.js"></script>
<script  type="text/javascript"  src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/requirejs-config.js"></script>
<script  type="text/javascript"  src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/Mageplaza_SocialShare/js/thankskit.js"></script>
<script  type="text/javascript"  src="https://static.addtoany.com/menu/page.js"></script>
<link rel="preload" as="font" crossorigin="anonymous" href="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/fonts/Luma-Icons.woff2" />
<link  rel="stylesheet" type="text/css" href="https://fonts.googleapis.com/css?family=Barlow:300,400,400i,500,600,700" />
<link  rel="stylesheet" type="text/css" href="https://fonts.googleapis.com/css?family=Montserrat:300,400,400i,500,600,700" />
<link  rel="icon" type="image/x-icon" href="https://kershaw.kaiusa.com/media/favicon/stores/7/kershaw_log_32x32.png" />
<link  rel="shortcut icon" type="image/x-icon" href="https://kershaw.kaiusa.com/media/favicon/stores/7/kershaw_log_32x32.png" />
<meta name="facebook-domain-verification" content="6vderaxoz72pb299py9ilte4uif4b9" />            <script type="text/x-magento-init">
        {
            "*": {
                "Magento_PageCache/js/form-key-provider": {
                    "isPaginationCacheEnabled":
                        0                }
            }
        }
    </script>

<script type="text/x-magento-init">
    {
        "*": {
           "YotpoSMS": { "store_id": "1J0qHOW27JZkeBkKRjpLiYw16Ms2Dzc7qDH3fXl8" }
        }
    }
</script>

<script>
    window.wtba = window.wtba || [];
        window.wtba.push({"type":"home","data":{"type":"home"}});
    </script>

    </head>
    <body data-container="body"
          data-mage-init='{"loaderAjax": {}, "loader": { "icon": "https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/loader-2.gif"}}'
        id="html-body" class="cms-home page-layout-1column cms-index-index page-layout-cms-full-width">
        
<script type="text/x-magento-init">
    {
        "*": {
            "Magento_PageBuilder/js/widget-initializer": {
                "config": {"[data-content-type=\"slider\"][data-appearance=\"default\"]":{"Magento_PageBuilder\/js\/content-type\/slider\/appearance\/default\/widget":false},"[data-content-type=\"map\"]":{"Magento_PageBuilder\/js\/content-type\/map\/appearance\/default\/widget":false},"[data-content-type=\"row\"]":{"Magento_PageBuilder\/js\/content-type\/row\/appearance\/default\/widget":false},"[data-content-type=\"tabs\"]":{"Magento_PageBuilder\/js\/content-type\/tabs\/appearance\/default\/widget":false},"[data-content-type=\"slide\"]":{"Magento_PageBuilder\/js\/content-type\/slide\/appearance\/default\/widget":{"buttonSelector":".pagebuilder-slide-button","showOverlay":"hover","dataRole":"slide"}},"[data-content-type=\"banner\"]":{"Magento_PageBuilder\/js\/content-type\/banner\/appearance\/default\/widget":{"buttonSelector":".pagebuilder-banner-button","showOverlay":"hover","dataRole":"banner"}},"[data-content-type=\"buttons\"]":{"Magento_PageBuilder\/js\/content-type\/buttons\/appearance\/inline\/widget":false},"[data-content-type=\"products\"][data-appearance=\"carousel\"]":{"Magento_PageBuilder\/js\/content-type\/products\/appearance\/carousel\/widget":false},"[data-content-type=\"products\"][data-appearance=\"carousel-with-stage\"]":{"BlueAcorn_PageBuilderContent\/js\/content-type\/products\/appearance\/carousel-with-stage\/widget":false},"[data-content-type=\"products\"][data-appearance=\"featured-product\"]":{"BlueAcorn_PageBuilderContent\/js\/content-type\/products\/appearance\/featured-product\/widget":false},"[data-content-type=\"mobile-accordion\"]":{"BlueAcorn_PageBuilderContent\/js\/content-type\/mobile-accordion\/appearance\/default\/widget":false},"[data-content-type=\"content-slider\"]":{"BlueAcorn_PageBuilderUpdates\/js\/content-type\/content-slider\/appearance\/default\/widget":false},"[data-content-type=\"video\"]":{"BlueAcorn_PageBuilderContent\/js\/content-type\/video\/appearance\/default\/widget":false},"[data-content-type=\"collapsible\"]":{"BlueAcorn_PageBuilderCollapsible\/js\/content-type\/collapsible\/appearance\/default\/widget":false},"[data-content-type=\"blueacorn-tabs\"]":{"BlueAcorn_PageBuilderContent\/js\/content-type\/blueacorn-tabs\/appearance\/default\/widget":false},"[data-content-type=\"accordion\"]":{"BlueAcorn_PageBuilderContent\/js\/content-type\/accordion\/appearance\/default\/widget":false}},
                "breakpoints": {"desktop":{"label":"Desktop","stage":true,"default":true,"class":"desktop-switcher","icon":"Magento_PageBuilder::css\/images\/switcher\/switcher-desktop.svg","conditions":{"min-width":"1024px"},"options":{"products":{"default":{"slidesToShow":"5"}}}},"tablet":{"conditions":{"max-width":"1024px","min-width":"768px"},"options":{"products":{"default":{"slidesToShow":"4"},"continuous":{"slidesToShow":"3"}}}},"mobile":{"label":"Mobile","stage":true,"class":"mobile-switcher","icon":"Magento_PageBuilder::css\/images\/switcher\/switcher-mobile.svg","media":"only screen and (max-width: 767px)","conditions":{"max-width":"767px","min-width":"640px"},"options":{"products":{"default":{"slidesToShow":"3"}}}},"mobile-small":{"conditions":{"max-width":"640px"},"options":{"products":{"default":{"slidesToShow":"2"},"continuous":{"slidesToShow":"1"}}}}}            }
        }
    }
</script>

<div class="cookie-status-message" id="cookie-status">
    The store will not work correctly when cookies are disabled.</div>
<script type="text&#x2F;javascript">document.querySelector("#cookie-status").style.display = "none";</script>
<script type="text/x-magento-init">
    {
        "*": {
            "cookieStatus": {}
        }
    }
</script>

<script type="text/x-magento-init">
    {
        "*": {
            "mage/cookies": {
                "expires": null,
                "path": "\u002F",
                "domain": ".kaiusa.com",
                "secure": true,
                "lifetime": "2592000"
            }
        }
    }
</script>
    <noscript>
        <div class="message global noscript">
            <div class="content">
                <p>
                    <strong>JavaScript seems to be disabled in your browser.</strong>
                    <span>
                        For the best experience on our site, be sure to turn on Javascript in your browser.                    </span>
                </p>
            </div>
        </div>
    </noscript>
<script>    require.config({
        map: {
            '*': {
                wysiwygAdapter: 'mage/adminhtml/wysiwyg/tiny_mce/tinymce5Adapter'
            }
        }
    });</script>    <div role="alertdialog"
         tabindex="-1"
         class="message global cookie"
         id="notice-cookie-block"
         aria-label="Cookie message">
        <div role="document" class="content" tabindex="0">
            <p>
                <strong>We use cookies to make your experience better.</strong>
                <span>
                    To comply with the new e-Privacy directive, we need to ask for your consent to set the cookies.                </span>
                <a href="https://kershaw.kaiusa.com/privacy-policy-cookie-restriction-mode/#CookiesPolicy">Learn more</a>.            </p>
            <div class="actions">
                <button id="btn-cookie-allow" class="action allow primary">
                    <span>Allow Cookies</span>
                </button>
                                    <a href="javascript:void(0);" id="btn-cookie-dismiss" class="action-dismiss">
                        No Thanks                    </a>
                            </div>
        </div>
    </div>
    <script type="text&#x2F;javascript">    var elemOzTI0Yl7Array = document.querySelectorAll('div#notice-cookie-block');
    if(elemOzTI0Yl7Array.length !== 'undefined'){
        elemOzTI0Yl7Array.forEach(function(element) {
            if (element) {
                element.style.display = 'none';

            }
        });
    }</script>    <script type="text/x-magento-init">
        {
            "#notice-cookie-block": {
                "cookieNotices": {
                    "cookieAllowButtonSelector": "#btn-cookie-allow",
                    "cookieDismissButtonSelector": "#btn-cookie-dismiss",
                    "cookieName": "user_allowed_save_cookie",
                    "dismissCookieName": "user_not_allowed_save_cookie",
                    "cookieValue": {"1":1},
                    "cookieLifetime": 31536000,
                    "noCookiesUrl": "https\u003A\u002F\u002Fkershaw.kaiusa.com\u002Fcookie\u002Findex\u002FnoCookies\u002F"
                }
            }
        }
    </script>

<script>
    window.cookiesConfig = window.cookiesConfig || {};
    window.cookiesConfig.secure = true;
</script><script>
    require.config({
        paths: {
            googleMaps: 'https\u003A\u002F\u002Fmaps.googleapis.com\u002Fmaps\u002Fapi\u002Fjs\u003Fv\u003D3\u0026key\u003D'
        },
        config: {
            'Magento_PageBuilder/js/utils/map': {
                style: ''
            },
            'Magento_PageBuilder/js/content-type/map/preview': {
                apiKey: '',
                apiKeyErrorMessage: 'You\u0020must\u0020provide\u0020a\u0020valid\u0020\u003Ca\u0020href\u003D\u0027https\u003A\u002F\u002Fkershaw.kaiusa.com\u002Fadminhtml\u002Fsystem_config\u002Fedit\u002Fsection\u002Fcms\u002F\u0023cms_pagebuilder\u0027\u0020target\u003D\u0027_blank\u0027\u003EGoogle\u0020Maps\u0020API\u0020key\u003C\u002Fa\u003E\u0020to\u0020use\u0020a\u0020map.'
            },
            'Magento_PageBuilder/js/form/element/map': {
                apiKey: '',
                apiKeyErrorMessage: 'You\u0020must\u0020provide\u0020a\u0020valid\u0020\u003Ca\u0020href\u003D\u0027https\u003A\u002F\u002Fkershaw.kaiusa.com\u002Fadminhtml\u002Fsystem_config\u002Fedit\u002Fsection\u002Fcms\u002F\u0023cms_pagebuilder\u0027\u0020target\u003D\u0027_blank\u0027\u003EGoogle\u0020Maps\u0020API\u0020key\u003C\u002Fa\u003E\u0020to\u0020use\u0020a\u0020map.'
            },
        }
    });
</script>

<script>
    require.config({
        shim: {
            'Magento_PageBuilder/js/utils/map': {
                deps: ['googleMaps']
            }
        }
    });
</script>
<div class="page-wrapper"><header class="page-header"><div class="header content"><a class="action skip contentarea"
   href="#contentarea">
    <span>
        Skip to Content    </span>
</a>
<div class="custom-header-container inner-content"><div class="custom-header-container-left"><a href="javascript:void(0);" data-action="toggle-nav" class="action nav-toggle">
    <span>
        Toggle Nav    </span>
</a>
<a
    class="logo"
    href="https://kershaw.kaiusa.com/"
    title=""
    aria-label="store logo">
    <img src="https://kershaw.kaiusa.com/media/logo/stores/7/Kershaw_50-Year_Graphic.png"
         title=""
         alt=""
            width="170"            height="100"    />
</a>
    <div id="header-store-switcher" class="header-store-switcher">
        <div class="header-store-switcher-anchor-container">
            <a href="javascript:void(0);" class="action toggle"
               data-toggle="dropdown" data-role="trigger"
               aria-haspopup="true" title="Select&#x20;Store"
               data-mage-init='{"dropdown":{}}'>
                <strong class="label switcher-label">
                    <i class="chevron"></i>
                    <span class="switcher-label-text">Select Store</span>
                </strong>
            </a>
        </div>
        <div class="switcher-content dropdown-options" data-target="dropdown">
            <style>#html-body [data-pb-style=DVLXRBW]{justify-content:flex-start;display:flex;flex-direction:column;background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll;border-style:none;border-width:1px;border-radius:0;margin:0 0 10px;padding:10px}#html-body [data-pb-style=HHQRWOO]{border-style:none;border-width:1px;border-radius:0;margin:0;padding:0}</style><div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" data-pb-style="DVLXRBW"><div data-content-type="html" data-appearance="default" data-element="main" data-pb-style="HHQRWOO" data-decoded="true"><ul class="websites-list">
    <li>
    <a href="https://zt.kaiusa.com/" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/stores\/store\/redirect\/","data":{"___store":"zt","___from_store":"kershaw","uenc":"aHR0cHM6Ly96dC5rYWl1c2EuY29tL2Ntcy9pbmRleC9pbmRleC8~"}}'>
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/zt-gray.png" alt="Zero Tolerance Logo">
    </a>
    </li>
    <li>
    <a href="https://shun.kaiusa.com/" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/stores\/store\/redirect\/","data":{"___store":"shun","___from_store":"kershaw","uenc":"aHR0cHM6Ly9zaHVuLmthaXVzYS5jb20vY21zL2luZGV4L2luZGV4Lw~~"}}'>
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/shun-gray.png" alt="Shun Logo">
    </a>
    </li>
    <li>
    <a href="https://housewares.kaiusa.com/" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/stores\/store\/redirect\/","data":{"___store":"housewares","___from_store":"kershaw","uenc":"aHR0cHM6Ly9ob3VzZXdhcmVzLmthaXVzYS5jb20vY21zL2luZGV4L2luZGV4Lw~~"}}'>
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/kai-housewares-gray.png" alt="Housewares Logo">
    </a>
    </li>
    <li>
    <a href="https://kasho.kaiusa.com/" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/stores\/store\/redirect\/","data":{"___store":"kasho","___from_store":"kershaw","uenc":"aHR0cHM6Ly9rYXNoby5rYWl1c2EuY29tL2Ntcy9pbmRleC9pbmRleC8~"}}'>
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/kasho-gray.png" alt="Kasho Logo">
    </a>
    </li>
    <li>
    <a href="https://www.kaiusa.com/" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/stores\/store\/redirect\/","data":{"___store":"default","___from_store":"kershaw","uenc":"aHR0cHM6Ly93d3cua2FpdXNhLmNvbS9jbXMvaW5kZXgvaW5kZXgv"}}'>
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/kai-usa-gray.png" alt="Kai USA Logo">
    </a>
    </li>
    </ul>
</div></div></div>        </div>
    </div>
    <div class="sections nav-sections">
                <div class="section-items nav-sections-items"
             data-mage-init='{"tabs":{"openedState":"active"}}'>
                                            <div class="section-item-title nav-sections-item-title"
                     data-role="collapsible">
                    <a class="nav-sections-item-switch"
                       data-toggle="switch" href="#store.menu">
                        Menu                    </a>
                </div>
                <div class="section-item-content nav-sections-item-content"
                     id="store.menu"
                     data-role="content">
                            <nav id="main-menu" class="main-menu">
        <ul class="main-menu__list"
            data-mage-init='{"menu":{
                "responsive":true, "expanded":true, "position":{"my":"left top","at":"left bottom"}
            },
            "baMenuAlignment":{}}'>
                                            <li
                    class="main-menu__item&#x20;main-menu__item--parent&#x20;shop                    menu-level0">
                    
<a
    href="#"
    class="main-menu__link"
     data-menu="menu-71378">
    Shop</a>

                            <ul class="main-menu__inner-list main-menu__inner-list--level1" data-menu="menu-71378">
                    <li class="mobile-only back-container">
                <a class="back-link">Back</a>
            </li>
                                        <li class="main-menu__inner-item main-menu__inner-item--level1 main-menu__inner-item--parent mega-menu">
                <div data-menu="menu-71381" class="main-menu__inner-link"></div>
                        <ul class="main-menu__inner-list main-menu__inner-list--level2" data-menu="menu-71381">
                                        <li class="main-menu__inner-item main-menu__inner-item--level2 main-menu__inner-item--parent column width-1 left-menu-item">
                <div data-menu="menu-71384" class="main-menu__inner-link"></div>
                        <ul class="main-menu__inner-list main-menu__inner-list--level3" data-menu="menu-71384">
                                        <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default">
                
<a
    href="https://kershaw.kaiusa.com/new.html"
    class="main-menu__inner-link"
     data-menu="menu-71387">
    New</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default">
                
<a
    href="https://kershaw.kaiusa.com/usa-made.html"
    class="main-menu__inner-link"
     data-menu="menu-73813">
    USA Made</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default">
                
<a
    href="https://kershaw.kaiusa.com/exclusive.html"
    class="main-menu__inner-link"
     data-menu="menu-73877">
    Exclusives</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default">
                
<a
    href="https://kershaw.kaiusa.com/bestsellers.html"
    class="main-menu__inner-link"
     data-menu="menu-71393">
    Bestsellers</a>

                            </li>
            </ul>
            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level2 main-menu__inner-item--parent column width-1">
                <div data-menu="menu-71399" class="main-menu__inner-link"></div>
                        <ul class="main-menu__inner-list main-menu__inner-list--level3" data-menu="menu-71399">
                                        <li class="main-menu__inner-item main-menu__inner-item--level3 main-menu__inner-item--parent menu-link-default is-bold level-1-parent">
                
<a
    href="#"
    class="main-menu__inner-link"
     data-menu="menu-71402">
    By Use</a>

                        <ul class="main-menu__inner-list main-menu__inner-list--level4" data-menu="menu-71402">
                                        <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/everyday.html"
    class="main-menu__inner-link"
     data-menu="menu-71405">
    Everyday</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/outdoor.html"
    class="main-menu__inner-link"
     data-menu="menu-71408">
    Outdoor</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/hunting.html"
    class="main-menu__inner-link"
     data-menu="menu-71411">
    Hunting</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/fishing.html"
    class="main-menu__inner-link"
     data-menu="menu-71414">
    Fishing</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/work.html"
    class="main-menu__inner-link"
     data-menu="menu-71417">
    Work</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/tactical.html"
    class="main-menu__inner-link"
     data-menu="menu-71420">
    Tactical</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/rescue.html"
    class="main-menu__inner-link"
     data-menu="menu-71423">
    Rescue</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/view-all.html"
    class="main-menu__inner-link"
     data-menu="menu-71426">
    View All</a>

                            </li>
            </ul>
            </li>
            </ul>
            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level2 main-menu__inner-item--parent column width-1">
                <div data-menu="menu-71429" class="main-menu__inner-link"></div>
                        <ul class="main-menu__inner-list main-menu__inner-list--level3" data-menu="menu-71429">
                                        <li class="main-menu__inner-item main-menu__inner-item--level3 main-menu__inner-item--parent menu-link-default is-bold level-1-parent">
                
<a
    href="#"
    class="main-menu__inner-link"
     data-menu="menu-71432">
    By Type</a>

                        <ul class="main-menu__inner-list main-menu__inner-list--level4" data-menu="menu-71432">
                                        <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/usa-made.html"
    class="main-menu__inner-link"
     data-menu="menu-73816">
    USA Made</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/assisted-opening.html"
    class="main-menu__inner-link"
     data-menu="menu-71435">
    Assisted</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/automatic.html"
    class="main-menu__inner-link"
     data-menu="menu-71438">
    Automatic</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/manual.html"
    class="main-menu__inner-link"
     data-menu="menu-71441">
    Manual</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/multi-function.html"
    class="main-menu__inner-link"
     data-menu="menu-71444">
    Multi-Function</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/fixed-blade.html"
    class="main-menu__inner-link"
     data-menu="menu-71447">
    Fixed Blade</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/gear.html"
    class="main-menu__inner-link"
     data-menu="menu-71450">
    Gear</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/apparel.html"
    class="main-menu__inner-link"
     data-menu="menu-71453">
    Apparel</a>

                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level4 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/view-all.html"
    class="main-menu__inner-link"
     data-menu="menu-71456">
    View All</a>

                            </li>
            </ul>
            </li>
            </ul>
            </li>
            </ul>
            </li>
            </ul>
                </li>
                                            <li
                    class="main-menu__item&#x20;main-menu__item--parent                    menu-level0">
                    
<a
    href="#"
    class="main-menu__link"
     data-menu="menu-71546">
    Learn</a>

                            <ul class="main-menu__inner-list main-menu__inner-list--level1" data-menu="menu-71546">
                    <li class="mobile-only back-container">
                <a class="back-link">Back</a>
            </li>
                                        <li class="main-menu__inner-item main-menu__inner-item--level1 main-menu__inner-item--parent mega-menu">
                <div data-menu="menu-71549" class="main-menu__inner-link"></div>
                        <ul class="main-menu__inner-list main-menu__inner-list--level2" data-menu="menu-71549">
                                        <li class="main-menu__inner-item main-menu__inner-item--level2 main-menu__inner-item--parent column width-1 align-column">
                <div data-menu="menu-71552" class="main-menu__inner-link"></div>
                        <ul class="main-menu__inner-list main-menu__inner-list--level3" data-menu="menu-71552">
                                        <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/buying-guide"
    class="main-menu__inner-link"
     data-menu="menu-71555">
    Buying Guide</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/product-care"
    class="main-menu__inner-link"
     data-menu="menu-71558">
    Product Care</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/usage-safety"
    class="main-menu__inner-link"
     data-menu="menu-71561">
    Usage & Safety</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/opening-systems"
    class="main-menu__inner-link"
     data-menu="menu-71564">
    Opening Systems</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/lock-types"
    class="main-menu__inner-link"
     data-menu="menu-71567">
    Lock Types</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/pocketclips"
    class="main-menu__inner-link"
     data-menu="menu-71570">
    Pocketclips</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/blade-styles"
    class="main-menu__inner-link"
     data-menu="menu-71573">
    Blade Styles</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/blade-steels"
    class="main-menu__inner-link"
     data-menu="menu-71576">
    Blade Steels</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/blade-coatings-finishes"
    class="main-menu__inner-link"
     data-menu="menu-71579">
    Blade Coatings & Finishes</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/blade-edges-grinds"
    class="main-menu__inner-link"
     data-menu="menu-71582">
    Blade Edges & Grinds</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/handle-materials"
    class="main-menu__inner-link"
     data-menu="menu-71585">
    Handle Materials</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/knife-anatomy"
    class="main-menu__inner-link"
     data-menu="menu-71588">
    Knife Anatomy</a>
                            </li>
            </ul>
            </li>
            </ul>
            </li>
            </ul>
                </li>
                                            <li
                    class="main-menu__item&#x20;main-menu__item--parent                    menu-level0">
                    
<a
    href="#"
    class="main-menu__link"
     data-menu="menu-71591">
    Support</a>

                            <ul class="main-menu__inner-list main-menu__inner-list--level1" data-menu="menu-71591">
                    <li class="mobile-only back-container">
                <a class="back-link">Back</a>
            </li>
                                        <li class="main-menu__inner-item main-menu__inner-item--level1 main-menu__inner-item--parent mega-menu">
                <div data-menu="menu-71594" class="main-menu__inner-link"></div>
                        <ul class="main-menu__inner-list main-menu__inner-list--level2" data-menu="menu-71594">
                                        <li class="main-menu__inner-item main-menu__inner-item--level2 main-menu__inner-item--parent column width-1 align-column">
                <div data-menu="menu-71597" class="main-menu__inner-link"></div>
                        <ul class="main-menu__inner-list main-menu__inner-list--level3" data-menu="menu-71597">
                                        <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/contact-us"
    class="main-menu__inner-link"
     data-menu="menu-71600">
    Contact Us</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
            href="/storelocator/"
        data-menu="menu-71603" class="main-menu__inner-link">
    Find a Dealer</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/faq"
    class="main-menu__inner-link"
     data-menu="menu-71606">
    FAQ</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/customer-service"
    class="main-menu__inner-link"
     data-menu="menu-71609">
    Customer Service</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/catalogs"
    class="main-menu__inner-link"
     data-menu="menu-71612">
    Catalogs & Downloads</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
            href="/warranty"
        data-menu="menu-71615" class="main-menu__inner-link">
    Warranty & Service</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
            href="/warranty#tab-form-2"
        data-menu="menu-71618" class="main-menu__inner-link">
    Replacement Parts</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/shipping-returns"
    class="main-menu__inner-link"
     data-menu="menu-71621">
    Shipping & Returns</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/counterfeits"
    class="main-menu__inner-link"
     data-menu="menu-71624">
    Counterfeits</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/discontinued.html"
    class="main-menu__inner-link"
     data-menu="menu-71627">
    Discontinued</a>

                            </li>
            </ul>
            </li>
            </ul>
            </li>
            </ul>
                </li>
                                            <li
                    class="main-menu__item&#x20;main-menu__item--parent                    menu-level0">
                    
<a
    href="#"
    class="main-menu__link"
     data-menu="menu-71630">
    About</a>

                            <ul class="main-menu__inner-list main-menu__inner-list--level1" data-menu="menu-71630">
                    <li class="mobile-only back-container">
                <a class="back-link">Back</a>
            </li>
                                        <li class="main-menu__inner-item main-menu__inner-item--level1 main-menu__inner-item--parent mega-menu">
                <div data-menu="menu-71633" class="main-menu__inner-link"></div>
                        <ul class="main-menu__inner-list main-menu__inner-list--level2" data-menu="menu-71633">
                                        <li class="main-menu__inner-item main-menu__inner-item--level2 main-menu__inner-item--parent column width-1 align-column">
                <div data-menu="menu-71636" class="main-menu__inner-link"></div>
                        <ul class="main-menu__inner-list main-menu__inner-list--level3" data-menu="menu-71636">
                                        <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/history"
    class="main-menu__inner-link"
     data-menu="menu-71639">
    Kershaw History</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/about-us"
    class="main-menu__inner-link"
     data-menu="menu-71642">
    About Us</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/manufacturing"
    class="main-menu__inner-link"
     data-menu="menu-71645">
    Manufacturing</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/become-a-dealer"
    class="main-menu__inner-link"
     data-menu="menu-71648">
    Become a Dealer</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/dealer-resources"
    class="main-menu__inner-link"
     data-menu="menu-71651">
    Dealer Resources</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/careers"
    class="main-menu__inner-link"
     data-menu="menu-71657">
    Careers</a>
                            </li>
                                <li class="main-menu__inner-item main-menu__inner-item--level3 menu-link-default is-dimmed">
                
<a
    href="https://kershaw.kaiusa.com/contact-us"
    class="main-menu__inner-link"
     data-menu="menu-71660">
    Donation Requests</a>
                            </li>
            </ul>
            </li>
            </ul>
            </li>
            </ul>
                </li>
                    </ul>
    </nav>
                </div>
                                            <div class="section-item-title nav-sections-item-title"
                     data-role="collapsible">
                    <a class="nav-sections-item-switch"
                       data-toggle="switch" href="#store.links">
                        Account                    </a>
                </div>
                <div class="section-item-content nav-sections-item-content"
                     id="store.links"
                     data-role="content">
                    <!-- Account links -->                </div>
                                    </div>
    </div>
</div><div class="custom-header-container-right"><div class="block block-search">
    <div class="block block-title"><strong>Search</strong></div>
    <div class="block block-content">
        <form class="form minisearch" id="search_mini_form"
              action="https://kershaw.kaiusa.com/catalogsearch/result/" method="get">
                        <div class="field search">
                <label class="label" for="search" data-role="minisearch-label">
                    <span>Search</span>
                </label>
                <div class="control">
                    <input id="search"
                           data-mage-init='{
                            "quickSearch": {
                                "formSelector": "#search_mini_form",
                                "url": "",
                                "destinationSelector": "#search_autocomplete",
                                "minSearchLength": "3"
                            }
                        }'
                           type="text"
                           name="q"
                           value=""
                           placeholder="Search"
                           class="input-text"
                           maxlength="128"
                           role="combobox"
                           aria-haspopup="false"
                           aria-autocomplete="both"
                           autocomplete="off"
                           aria-expanded="false"/>
                    <div id="search_autocomplete" class="search-autocomplete"></div>
                    <div class="nested">
    <a class="action advanced" href="https://kershaw.kaiusa.com/catalogsearch/advanced/" data-action="advanced-search">
        Advanced Search    </a>
</div>
                </div>
            </div>
            <div class="actions">
                <button type="submit"
                        title="Search"
                        class="action search"
                        aria-label="Search"
                >
                    <span>Search</span>
                </button>
            </div>
        </form>
    </div>
</div>

<div class="custom-header-links-wrapper">
    <a href="javascript:void(0);"
       class="custom-header-links-action"
       title="Open&#x20;Header&#x20;Links"></a>
    <div class="custom-header-links"
         data-role="dropdownDialog"
         data-mage-init='{"dropdownDialog":{
                "appendTo":".custom-header-links-wrapper",
                "triggerTarget":".custom-header-links-action",
                "timeout": "200",
                "closeOnEscape": true,
                "parentClass":"active",
                "buttons":[]}}'>
        <ul class="header links">    <li class="greet welcome" data-bind="scope: 'customer'">
        <!-- ko if: customer().fullname  -->
        <span class="logged-in"
              data-bind="text: new String('Welcome, %1!').
              replace('%1', customer().fullname)">
        </span>
        <!-- /ko -->
        <!-- ko ifnot: customer().fullname  -->
        <span class="not-logged-in"
              data-bind="text: 'Welcome to Kershaw Knives. Pocketknives for everyday carrying, work, tactical use, and more, rise to the next level and find your new favorite knife here.'"></span>
                <!-- /ko -->
    </li>
        <script type="text/x-magento-init">
        {
            "*": {
                "Magento_Ui/js/core/app": {
                    "components": {
                        "customer": {
                            "component": "Magento_Customer/js/view/customer"
                        }
                    }
                }
            }
        }
    </script>
<li class="link authorization-link" data-label="or">
    <a href="https://kershaw.kaiusa.com/customer/account/login/referer/aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20vY21zL2luZGV4L2luZGV4Lw~~/"        >Login/Create New Account</a>
</li>
</ul>    </div>
</div>

<div data-block="minicart" class="minicart-wrapper">
    <a class="action showcart" href="https://kershaw.kaiusa.com/checkout/cart/"
       data-bind="scope: 'minicart_content'">
        <div class="minicart-button" data-bind="css: { empty: !!getCartParam('summary_count') == false }">
            <span class="text">My Cart</span>
            <span class="counter qty empty"
                  data-bind="css: { empty: !!getCartParam('summary_count') == false && !isLoading() },
                   blockLoader: isLoading">
                <span class="counter-number">
                    <!-- ko if: getCartParam('summary_count') -->
                    <!-- ko text: getCartParam('summary_count').toLocaleString(window.LOCALE) --><!-- /ko -->
                    <!-- /ko -->
                </span>
                <span class="counter-label">
                <!-- ko if: getCartParam('summary_count') -->
                    <!-- ko text: getCartParam('summary_count').toLocaleString(window.LOCALE) --><!-- /ko -->
                    <!-- ko i18n: 'items' --><!-- /ko -->
                    <!-- /ko -->
                </span>
            </span>
        </div>
    </a>
            <div class="block block-minicart"
             data-role="dropdownDialog"
             data-mage-init='{"dropdownDialog":{
                "appendTo":"[data-block=minicart]",
                "triggerTarget":".showcart",
                "timeout": "2000",
                "closeOnMouseLeave": false,
                "closeOnEscape": true,
                "triggerClass":"active",
                "parentClass":"active",
                "buttons":[]}}'>
            <div id="minicart-content-wrapper" data-bind="scope: 'minicart_content'">
                <!-- ko template: getTemplate() --><!-- /ko -->
            </div>
                    </div>
        <script>window.checkout = {"shoppingCartUrl":"https:\/\/kershaw.kaiusa.com\/checkout\/cart\/","checkoutUrl":"https:\/\/kershaw.kaiusa.com\/checkout\/","updateItemQtyUrl":"https:\/\/kershaw.kaiusa.com\/checkout\/sidebar\/updateItemQty\/","removeItemUrl":"https:\/\/kershaw.kaiusa.com\/checkout\/sidebar\/removeItem\/","imageTemplate":"Magento_Catalog\/product\/image_with_borders","baseUrl":"https:\/\/kershaw.kaiusa.com\/","minicartMaxItemsVisible":5,"websiteId":"1","maxItemsToDisplay":10,"storeId":"7","storeGroupId":"7","agreementIds":["5"],"customerLoginUrl":"https:\/\/kershaw.kaiusa.com\/customer\/account\/login\/referer\/aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20vY21zL2luZGV4L2luZGV4Lw~~\/","isRedirectRequired":false,"autocomplete":"off","captcha":{"user_login":{"isCaseSensitive":false,"imageHeight":50,"imageSrc":"","refreshUrl":"https:\/\/kershaw.kaiusa.com\/captcha\/refresh\/","isRequired":false,"timestamp":1714562044}}}</script>    <script type="text/x-magento-init">
    {
        "[data-block='minicart']": {
            "Magento_Ui/js/core/app": {"components":{"minicart_content":{"children":{"subtotal.container":{"children":{"subtotal":{"children":{"subtotal.totals":{"config":{"display_cart_subtotal_incl_tax":0,"display_cart_subtotal_excl_tax":1,"template":"Magento_Tax\/checkout\/minicart\/subtotal\/totals"},"component":"Magento_Tax\/js\/view\/checkout\/minicart\/subtotal\/totals","children":{"subtotal.totals.msrp":{"component":"Magento_Msrp\/js\/view\/checkout\/minicart\/subtotal\/totals","config":{"displayArea":"minicart-subtotal-hidden","template":"Magento_Msrp\/checkout\/minicart\/subtotal\/totals"}}}}},"component":"uiComponent","config":{"template":"Magento_Checkout\/minicart\/subtotal"}}},"component":"uiComponent","config":{"displayArea":"subtotalContainer"}},"item.renderer":{"component":"Magento_Checkout\/js\/view\/cart-item-renderer","config":{"displayArea":"defaultRenderer","template":"Magento_Checkout\/minicart\/item\/default"},"children":{"item.image":{"component":"Magento_Catalog\/js\/view\/image","config":{"template":"Magento_Catalog\/product\/image","displayArea":"itemImage"}},"checkout.cart.item.price.sidebar":{"component":"uiComponent","config":{"template":"Magento_Checkout\/minicart\/item\/price","displayArea":"priceSidebar"}}}},"extra_info":{"component":"uiComponent","config":{"displayArea":"extraInfo"}},"promotion":{"component":"uiComponent","config":{"displayArea":"promotion"}}},"config":{"itemRenderer":{"default":"defaultRenderer","simple":"defaultRenderer","virtual":"defaultRenderer"},"template":"Magento_Checkout\/minicart\/content"},"component":"Magento_Checkout\/js\/view\/minicart"}},"types":[]}        },
        "*": {
            "Magento_Ui/js/block-loader": "https\u003A\u002F\u002Fkershaw.kaiusa.com\u002Fstatic\u002Fversion1713440747\u002Ffrontend\u002FBlueAcorn\u002Fkershaw\u002Fen_US\u002Fimages\u002Floader\u002D1.gif"
        }
    }
    </script>
</div>
</div></div><ul class="compare wrapper"><li class="item link compare" data-bind="scope: 'compareProducts'" data-role="compare-products-link">
    <a class="action compare no-display" title="Compare&#x20;Products"
       data-bind="attr: {'href': compareProducts().listUrl}, css: {'no-display': !compareProducts().count}"
    >
        Compare Products        <span class="counter qty" data-bind="text: compareProducts().countCaption"></span>
    </a>
</li>
<script type="text/x-magento-init">
{"[data-role=compare-products-link]": {"Magento_Ui/js/core/app": {"components":{"compareProducts":{"component":"Magento_Catalog\/js\/view\/compare-products"}}}}}
</script>
</ul></div><script type="application/javascript" async
 src="https://static.klaviyo.com/onsite/js/klaviyo.js?company_id=XpKKhU"></script>

    <script type="text/x-magento-init">
        {
            "*": {
                "KlaviyoCustomerData": {}
            }
        }
    </script>
<div class="custom-header-banner"><style>#html-body [data-pb-style=EFH30LY],#html-body [data-pb-style=QQWOCUU]{justify-content:flex-start;display:flex;flex-direction:column;background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll;border-style:none;border-width:1px;border-radius:0;margin:0 0 10px;padding:10px}#html-body [data-pb-style=BU3XECG]{display:none}#html-body [data-pb-style=BU3XECG],#html-body [data-pb-style=KMQFOV5],#html-body [data-pb-style=LL3LOO1]{border-style:none;border-width:1px;border-radius:0;margin:0;padding:0}#html-body [data-pb-style=LL3LOO1]{display:none}</style><div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" data-pb-style="EFH30LY"><div data-content-type="text" data-appearance="default" data-element="main" data-pb-style="BU3XECG"><p id="T2UK5MK">FREE STANDARD SHIPPING ON ORDERS OF $50 OR MORE.</p></div></div></div><div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" data-pb-style="QQWOCUU"><div data-content-type="text" data-appearance="default" data-element="main" data-pb-style="KMQFOV5"><p style="text-align: center;">FREE STANDARD SHIPPING ON ORDERS OF $100 OR MORE.</p></div><div data-content-type="text" data-appearance="default" data-element="main" data-pb-style="LL3LOO1"><p style="text-align: center;">KAI USA IS CLOSED WEDNESDAY JANUARY 17TH, DUE TO INCLEMENT WEATHER.</p></div></div></div></div></header><main id="maincontent" class="page-main-full-width"><div class="page messages"><div data-placeholder="messages"></div>
<div data-bind="scope: 'messages'">
    <!-- ko if: cookieMessages && cookieMessages.length > 0 -->
    <div aria-atomic="true" role="alert" data-bind="foreach: { data: cookieMessages, as: 'message' }" class="messages">
        <div data-bind="attr: {
            class: 'message-' + message.type + ' ' + message.type + ' message',
            'data-ui-id': 'message-' + message.type
        }">
            <div data-bind="html: $parent.prepareMessageForHtml(message.text)"></div>
        </div>
    </div>
    <!-- /ko -->

    <!-- ko if: messages().messages && messages().messages.length > 0 -->
    <div aria-atomic="true" role="alert" class="messages" data-bind="foreach: {
        data: messages().messages, as: 'message'
    }">
        <div data-bind="attr: {
            class: 'message-' + message.type + ' ' + message.type + ' message',
            'data-ui-id': 'message-' + message.type
        }">
            <div data-bind="html: $parent.prepareMessageForHtml(message.text)"></div>
        </div>
    </div>
    <!-- /ko -->
</div>
<script type="text/x-magento-init">
    {
        "*": {
            "Magento_Ui/js/core/app": {
                "components": {
                        "messages": {
                            "component": "Magento_Theme/js/view/messages"
                        }
                    }
                }
            }
    }
</script>
</div><a id="contentarea" tabindex="-1"></a>
<div class="columns"><div class="column main">
    

<input name="form_key" type="hidden" value="MCgdl3NXbPFWvg6g" /><div id="authenticationPopup" data-bind="scope:'authenticationPopup', style: {display: 'none'}">
        <script>window.authenticationPopup = {"autocomplete":"off","customerRegisterUrl":"https:\/\/kershaw.kaiusa.com\/customer\/account\/create\/","customerForgotPasswordUrl":"https:\/\/kershaw.kaiusa.com\/customer\/account\/forgotpassword\/","baseUrl":"https:\/\/kershaw.kaiusa.com\/","customerLoginUrl":"https:\/\/kershaw.kaiusa.com\/customer\/ajax\/login\/"}</script>    <!-- ko template: getTemplate() --><!-- /ko -->
        <script type="text/x-magento-init">
        {
            "#authenticationPopup": {
                "Magento_Ui/js/core/app": {"components":{"authenticationPopup":{"component":"Magento_Customer\/js\/view\/authentication-popup","children":{"messages":{"component":"Magento_Ui\/js\/view\/messages","displayArea":"messages"},"captcha":{"component":"Magento_Captcha\/js\/view\/checkout\/loginCaptcha","displayArea":"additional-login-form-fields","formId":"user_login","configSource":"checkout"},"recaptcha":{"component":"Magento_ReCaptchaFrontendUi\/js\/reCaptcha","displayArea":"additional-login-form-fields","reCaptchaId":"recaptcha-popup-login","settings":{"rendering":{"sitekey":"6Lc2KLoUAAAAAHriReRcKp_k3FuADvgGNHEOHyyn","badge":"inline","size":"invisible","theme":"light","hl":""},"invisible":true}}}}}}            },
            "*": {
                "Magento_Ui/js/block-loader": "https\u003A\u002F\u002Fkershaw.kaiusa.com\u002Fstatic\u002Fversion1713440747\u002Ffrontend\u002FBlueAcorn\u002Fkershaw\u002Fen_US\u002Fimages\u002Floader\u002D1.gif"
                                ,
                "Magento_Customer/js/customer-global-session-loader": {}
                            }
        }
    </script>
</div>
<script type="text/x-magento-init">
    {
        "*": {
            "Magento_Customer/js/section-config": {
                "sections": {"stores\/store\/switch":["*"],"stores\/store\/switchrequest":["*"],"directory\/currency\/switch":["*"],"*":["messages","location"],"customer\/account\/logout":["*","recently_viewed_product","recently_compared_product","persistent","signifyd-fingerprint","yotposms-customer-behaviour"],"customer\/account\/loginpost":["*"],"customer\/account\/createpost":["*"],"customer\/account\/editpost":["*"],"customer\/ajax\/login":["checkout-data","cart","captcha","signifyd-fingerprint"],"catalog\/product_compare\/add":["compare-products","wp_ga4"],"catalog\/product_compare\/remove":["compare-products"],"catalog\/product_compare\/clear":["compare-products"],"sales\/guest\/reorder":["cart","ammessages"],"sales\/order\/reorder":["cart","ammessages"],"checkout\/cart\/add":["cart","directory-data","ammessages","signifyd-fingerprint","wp_ga4","yotposms-customer-behaviour"],"checkout\/cart\/delete":["cart","ammessages","wp_ga4"],"checkout\/cart\/updatepost":["cart","ammessages","wp_ga4"],"checkout\/cart\/updateitemoptions":["cart","ammessages","wp_ga4"],"checkout\/cart\/couponpost":["cart","ammessages"],"checkout\/cart\/estimatepost":["cart","ammessages"],"checkout\/cart\/estimateupdatepost":["cart","ammessages"],"checkout\/onepage\/saveorder":["cart","checkout-data","last-ordered-items","ammessages"],"checkout\/sidebar\/removeitem":["cart","ammessages","wp_ga4"],"checkout\/sidebar\/updateitemqty":["cart","ammessages","wp_ga4"],"rest\/*\/v1\/carts\/*\/payment-information":["cart","last-ordered-items","captcha","instant-purchase","ammessages","wp_ga4"],"rest\/*\/v1\/guest-carts\/*\/payment-information":["cart","captcha","ammessages","wp_ga4"],"rest\/*\/v1\/guest-carts\/*\/selected-payment-method":["cart","checkout-data","ammessages"],"rest\/*\/v1\/carts\/*\/selected-payment-method":["cart","checkout-data","instant-purchase","ammessages"],"wishlist\/index\/add":["wishlist","wp_ga4"],"wishlist\/index\/remove":["wishlist"],"wishlist\/index\/updateitemoptions":["wishlist"],"wishlist\/index\/update":["wishlist"],"wishlist\/index\/cart":["wishlist","cart","wp_ga4"],"wishlist\/index\/fromcart":["wishlist","cart"],"wishlist\/index\/allcart":["wishlist","cart","wp_ga4"],"wishlist\/shared\/allcart":["wishlist","cart"],"wishlist\/shared\/cart":["cart"],"giftregistry\/index\/cart":["cart"],"giftregistry\/view\/addtocart":["cart"],"customer_order\/cart\/updatefaileditemoptions":["cart"],"checkout\/cart\/updatefaileditemoptions":["cart"],"customer_order\/cart\/advancedadd":["cart"],"checkout\/cart\/advancedadd":["cart"],"checkout\/cart\/removeallfailed":["cart"],"checkout\/cart\/removefailed":["cart"],"customer_order\/cart\/addfaileditems":["cart"],"checkout\/cart\/addfaileditems":["cart"],"customer_order\/sku\/uploadfile":["cart"],"customer\/address\/*":["instant-purchase"],"customer\/account\/*":["instant-purchase"],"vault\/cards\/deleteaction":["instant-purchase"],"multishipping\/checkout\/overviewpost":["cart","ammessages"],"wishlist\/index\/copyitem":["wishlist"],"wishlist\/index\/copyitems":["wishlist"],"wishlist\/index\/deletewishlist":["wishlist","multiplewishlist"],"wishlist\/index\/createwishlist":["multiplewishlist"],"wishlist\/index\/editwishlist":["multiplewishlist"],"wishlist\/index\/moveitem":["wishlist"],"wishlist\/index\/moveitems":["wishlist"],"wishlist\/search\/addtocart":["cart","wishlist"],"paypal\/express\/placeorder":["cart","checkout-data","ammessages"],"paypal\/payflowexpress\/placeorder":["cart","checkout-data","ammessages"],"paypal\/express\/onauthorization":["cart","checkout-data","ammessages"],"persistent\/index\/unsetcookie":["persistent"],"review\/product\/post":["review"],"amasty_promo\/cart\/add":["cart","ammessages"],"braintree\/paypal\/placeorder":["ammessages","cart","checkout-data"],"authorizenet\/directpost_payment\/place":["ammessages"],"warranty\/index\/index":["warranty"],"reclaim\/checkout\/reload":["cart"],"checkout\/cart\/addgroup":["signifyd-fingerprint"],"checkout\/cart\/index":["signifyd-fingerprint"],"customer\/account\/login-post":["signifyd-fingerprint"],"customer\/account\/create-post":["signifyd-fingerprint"],"checkout\/onepage\/success":["signifyd-fingerprint"],"checkout\/onepage\/save-order":["signifyd-fingerprint"],"amasty_cart\/cart\/add":["signifyd-fingerprint"],"braintree\/googlepay\/placeorder":["cart","checkout-data"],"checkout\/cart\/configure":["wp_ga4"],"rest\/*\/v1\/guest-carts\/*\/shipping-information":["wp_ga4"],"rest\/*\/v1\/carts\/*\/shipping-information":["wp_ga4"],"customer\/account\/login":["yotposms-customer-behaviour"]},
                "clientSideSections": ["checkout-data","cart-data","BLUE_ACORN_SEARCH_LOCATION"],
                "baseUrls": ["https:\/\/kershaw.kaiusa.com\/"],
                "sectionNames": ["messages","customer","compare-products","last-ordered-items","cart","directory-data","captcha","wishlist","instant-purchase","loggedAsCustomer","multiplewishlist","persistent","review","ammessages","warranty","signifyd-fingerprint","webforms","location","checkout-data","wp_ga4","yotposms-customer-behaviour","recently_viewed_product","recently_compared_product","product_data_storage","paypal-billing-agreement"]            }
        }
    }
</script>
<script type="text/x-magento-init">
    {
        "*": {
            "Magento_Customer/js/customer-data": {
                "sectionLoadUrl": "https\u003A\u002F\u002Fkershaw.kaiusa.com\u002Fcustomer\u002Fsection\u002Fload\u002F",
                "expirableSectionLifetime": 60,
                "expirableSectionNames": ["cart","persistent"],
                "cookieLifeTime": "2592000",
                "updateSessionUrl": "https\u003A\u002F\u002Fkershaw.kaiusa.com\u002Fcustomer\u002Faccount\u002FupdateSession\u002F"
            }
        }
    }
</script>
<script type="text/x-magento-init">
    {
        "*": {
            "Magento_Customer/js/invalidation-processor": {
                "invalidationRules": {
                    "website-rule": {
                        "Magento_Customer/js/invalidation-rules/website-rule": {
                            "scopeConfig": {
                                "websiteId": "1"
                            }
                        }
                    }
                }
            }
        }
    }
</script>
<script type="text/x-magento-init">
    {
        "body": {
            "pageCache": {"url":"https:\/\/kershaw.kaiusa.com\/page_cache\/block\/render\/","handles":["default","cms_index_index","cms_page_view","cms_index_index_id_home"],"originalRequest":{"route":"cms","controller":"index","action":"index","uri":"\/knivesTools\/images\/ETUCBLK.jpg"},"versionCookieName":"private_content_version"}        }
    }
</script>
<script type="text/x-magento-init">
{
    "*": {
        "Magento_Banner/js/model/banner":
            {"sectionLoadUrl":"https:\/\/kershaw.kaiusa.com\/banner\/ajax\/load\/","cacheTtl":30000}        }
}
</script>

<script type="text/x-magento-init">
    {
        "*": {
           "Magento_Ui/js/core/app": {
                "components": {
                    "miniCartReload": {
                        "component":"baCartReload",
                        "isRedirected": ""
                    }
                }
           }
        }
    }

</script>
<div class="signing-restriction-modal">
    <img class="store-logo" src='https&#x3A;&#x2F;&#x2F;kershaw.kaiusa.com&#x2F;static&#x2F;version1713440747&#x2F;frontend&#x2F;BlueAcorn&#x2F;kershaw&#x2F;en_US&#x2F;images&#x2F;logo.svg'
         alt="Store Logo">
    <h2 class="form-title signing-restriction-form-element">
        Automatic Knife Release Form    </h2>
    

    <div id="webform_Km6Y1l_success_text" class="std webforms-success-text"
         style="display:none"></div>

    
    <div id="webform_Km6Y1l_form" class="webforms">

                    <div id="Km6Y1lform_description" class="webforms-description-text">
                <p>You must read and fill out this form before Kai USA, Ltd. can sell to you, or ship to you, any Automatic or Butterfly Knives. By electronically signing this online form, you confirm that you are in compliance with the federal statutes shown below as well as any applicable state and local regulation.</p>
<p>By placing an order or receiving a product service (such as warranty repair service) from us, you agree that you meet any or all of the following criteria:</p>
<h2>APPLICABLE FEDERAL STATUTES</h2>
<h3>18 U.S.C. § 1716 (G) (2) (1-4) provides, in summary:</h3>
<p>Switchblade (automatic) knives can be shipped to civilian and armed forces supply or procurement officers and employees of the federal government ordering or procuring or purchasing such knives in connection with activities of the Federal government; to supply or procurement officers in the National Guard, the Air National Guard or militia of the state or territory of the District of Columbia ordering, procuring or purchasing such knives in connections with the activities of such organizations; to supply or procurement officers or employees of the municipal government of the District of Columbia or the government of any state or territory of any county, city or other political subdivision of a state or territory ordering, procuring or purchasing such knives in connection with the activities of such government.</p>
<h3>15 U.S.C. § 1244 provides, in summary:</h3>
<p>Knives can be shipped by common carrier; that sale, transportation or distribution, possession or introduction into interstate commerce of switchblade knives is authorized if it is pursuant to a contract with the armed forces; or, any member or employee thereof acting in the performance of his or her duty may possess switchblade knives and may have them shipped to him and sold to him or her. The possession and transportation upon his or her person of a switchblade knife or a blade 3 inches or less is authorized to any handicapped individual who has the use of only one arm.</p>
<h2>STATE LAW PROVISIONS</h2>
<p>It would be impossible to provide an exhaustive review of the laws that may apply in the various fifty states and in the various counties, parishes, municipalities, and other political subdivisions within each state. By signing this form below, you will be certifying that in addition to complying with federal law, you have determined which, if any, state or local laws apply to you, and that you are acting in compliance with those laws.</p>
<p>No Post Office Box addresses can be used on this form. Item(s) must be sent in going UPS or Fed Ex. No USPS shipments will be accepted. If the address that you have filled out on this form is no longer a valid address, you must contact us and fill out a new form.</p>            </div>
        
        <form method="post"
      name="webform_Km6Y1l"
      id="webform_Km6Y1l"
      enctype="multipart/form-data"
      class="form "
      style=""
            aria-label="Automatic Knife Release Form"
      role="none">

    <input name="form_key" type="hidden"/>
    <input type="hidden" name="submitForm_47" value="1"/>
    <input type="hidden" name="form_id" value="47"/>
    
    
    
    <fieldset id="fieldset_Km6Y1l134"
          class="fieldset fieldset-134 f-18-form-customer-information wf-lg-1-1 wf-md-1-1 wf-sm-1-1"
          style=""
          role="group"
          aria-labelledby="legend_Km6Y1l134">

            <h3 class="legend" id="legend_Km6Y1l134">
            <span>Customer Information</span>
        </h3>
    
    <div id="field_Km6Y1l272" role="group"
     class="field  wf-lg-1-1 wf-md-1-1 wf-sm-1-1 type-text webforms-fields-272 webforms-fields-f-18-form-w-50 f-18-form-customer-information-first-name required"
    aria-labelledby="label_fieldKm6Y1l272"    >

            <label class="label"
               id="label_fieldKm6Y1l272"
            for="fieldKm6Y1l272">
            First Name                    </label>
    
    <div class="control" role="group" aria-labelledby="label_fieldKm6Y1l272">
        <input id='fieldKm6Y1l272'
       name='field[272]'
       type='text'
       class='input-text '
       style=''
       value=""
       placeholder="Enter First Name"
                  data-validate="{'required-entry':true}"
                      aria-labelledby="label_fieldKm6Y1l272"        aria-required="true"                     data-mage-init='{
            "MageMe_WebForms/js/prefill": {
                "attribute": ""
            }
       }'
/>

        
            </div>

</div><div id="field_Km6Y1l275" role="group"
     class="field  wf-lg-1-1 wf-md-1-1 wf-sm-1-1 type-text webforms-fields-275 webforms-fields-f-18-form-w-50 f-18-form-customer-information-last-name required"
    aria-labelledby="label_fieldKm6Y1l275"    >

            <label class="label"
               id="label_fieldKm6Y1l275"
            for="fieldKm6Y1l275">
            Last Name                    </label>
    
    <div class="control" role="group" aria-labelledby="label_fieldKm6Y1l275">
        <input id='fieldKm6Y1l275'
       name='field[275]'
       type='text'
       class='input-text '
       style=''
       value=""
       placeholder="Enter Last Name"
                  data-validate="{'required-entry':true}"
                      aria-labelledby="label_fieldKm6Y1l275"        aria-required="true"                     data-mage-init='{
            "MageMe_WebForms/js/prefill": {
                "attribute": ""
            }
       }'
/>

        
            </div>

</div><div id="field_Km6Y1l278" role="group"
     class="field  wf-lg-1-1 wf-md-1-1 wf-sm-1-1 type-text webforms-fields-278 webforms-fields-f-18-form-w-50 f-18-form-customer-information-address-line-1 required"
    aria-labelledby="label_fieldKm6Y1l278"    >

            <label class="label"
               id="label_fieldKm6Y1l278"
            for="fieldKm6Y1l278">
            Address line 1                    </label>
    
    <div class="control" role="group" aria-labelledby="label_fieldKm6Y1l278">
        <input id='fieldKm6Y1l278'
       name='field[278]'
       type='text'
       class='input-text '
       style=''
       value=""
       placeholder="Enter Address"
                  data-validate="{'required-entry':true}"
                      aria-labelledby="label_fieldKm6Y1l278"        aria-required="true"                     data-mage-init='{
            "MageMe_WebForms/js/prefill": {
                "attribute": ""
            }
       }'
/>

        
            </div>

</div><div id="field_Km6Y1l281" role="group"
     class="field  wf-lg-1-1 wf-md-1-1 wf-sm-1-1 type-text webforms-fields-281 webforms-fields-f-18-form-w-50 f-18-form-customer-information-address-line-2 "
    aria-labelledby="label_fieldKm6Y1l281"    >

            <label class="label"
               id="label_fieldKm6Y1l281"
            for="fieldKm6Y1l281">
            Address line 2                    </label>
    
    <div class="control" role="group" aria-labelledby="label_fieldKm6Y1l281">
        <input id='fieldKm6Y1l281'
       name='field[281]'
       type='text'
       class='input-text '
       style=''
       value=""
       placeholder="Enter Address  (Optional)"
                      aria-labelledby="label_fieldKm6Y1l281"                             data-mage-init='{
            "MageMe_WebForms/js/prefill": {
                "attribute": ""
            }
       }'
/>

        
            </div>

</div><div id="field_Km6Y1l284" role="group"
     class="field  wf-lg-1-1 wf-md-1-1 wf-sm-1-1 type-text webforms-fields-284 webforms-fields-f-18-form-w-50 f-18-form-customer-information-city required"
    aria-labelledby="label_fieldKm6Y1l284"    >

            <label class="label"
               id="label_fieldKm6Y1l284"
            for="fieldKm6Y1l284">
            City                    </label>
    
    <div class="control" role="group" aria-labelledby="label_fieldKm6Y1l284">
        <input id='fieldKm6Y1l284'
       name='field[284]'
       type='text'
       class='input-text '
       style=''
       value=""
       placeholder="Enter City"
                  data-validate="{'required-entry':true}"
                      aria-labelledby="label_fieldKm6Y1l284"        aria-required="true"                     data-mage-init='{
            "MageMe_WebForms/js/prefill": {
                "attribute": ""
            }
       }'
/>

        
            </div>

</div><div id="field_Km6Y1l287" role="group"
     class="field  wf-lg-1-1 wf-md-1-1 wf-sm-1-1 type-region webforms-fields-287 webforms-fields-f-18-form-w-25 f-18-form-customer-information-state "
    aria-labelledby="label_fieldKm6Y1l287"    >

            <label class="label"
               id="label_fieldKm6Y1l287"
            for="fieldKm6Y1l287">
            State                    </label>
    
    <div class="control" role="group" aria-labelledby="label_fieldKm6Y1l287">
        <select id='fieldKm6Y1l287region_id'
        name='field[287][region_id]'
        title='field[287]'
        class=' region_id'
        style='display:none;'
                 aria-labelledby="label_fieldKm6Y1l287"                     >
    <option value="">Please select a region, state or province.</option>
</select>
<input id='fieldKm6Y1l287region'
       name='field[287][region]'
       type='text'
       title='field[287]'
       class=' input-text'
       style='display:none;'
       value=""
                aria-labelledby="label_fieldKm6Y1l287"                   />
<script type="text/x-magento-init">
    {
        "#fieldKm6Y1l293": {
            "webformsRegion": {
                "optionalRegionAllowed": true,
                "regionListId": "#fieldKm6Y1l287region_id",
                "regionInputId": "#fieldKm6Y1l287region",
                "regionJson": {"config":{"show_all_regions":true,"regions_required":["US"]},"US":{"4":{"code":"AL","name":"ALABAMA"},"7":{"code":"AK","name":"ALASKA"},"13":{"code":"AZ","name":"ARIZONA"},"16":{"code":"AR","name":"ARKANSAS"},"19":{"code":"AE","name":"ARMED FORCES AFRICA"},"22":{"code":"AA","name":"ARMED FORCES AMERICAS"},"25":{"code":"AE","name":"ARMED FORCES CANADA"},"28":{"code":"AE","name":"ARMED FORCES EUROPE"},"31":{"code":"AE","name":"ARMED FORCES MIDDLE EAST"},"34":{"code":"AP","name":"ARMED FORCES PACIFIC"},"37":{"code":"CA","name":"CALIFORNIA"},"40":{"code":"CO","name":"COLORADO"},"43":{"code":"CT","name":"CONNECTICUT"},"46":{"code":"DE","name":"DELAWARE"},"49":{"code":"DC","name":"DISTRICT OF COLUMBIA"},"55":{"code":"FL","name":"FLORIDA"},"58":{"code":"GA","name":"GEORGIA"},"64":{"code":"HI","name":"HAWAII"},"67":{"code":"ID","name":"IDAHO"},"70":{"code":"IL","name":"ILLINOIS"},"73":{"code":"IN","name":"INDIANA"},"76":{"code":"IA","name":"IOWA"},"79":{"code":"KS","name":"KANSAS"},"82":{"code":"KY","name":"KENTUCKY"},"85":{"code":"LA","name":"LOUISIANA"},"88":{"code":"ME","name":"MAINE"},"94":{"code":"MD","name":"MARYLAND"},"97":{"code":"MA","name":"MASSACHUSETTS"},"100":{"code":"MI","name":"MICHIGAN"},"103":{"code":"MN","name":"MINNESOTA"},"106":{"code":"MS","name":"MISSISSIPPI"},"109":{"code":"MO","name":"MISSOURI"},"112":{"code":"MT","name":"MONTANA"},"115":{"code":"NE","name":"NEBRASKA"},"118":{"code":"NV","name":"NEVADA"},"121":{"code":"NH","name":"NEW HAMPSHIRE"},"124":{"code":"NJ","name":"NEW JERSEY"},"127":{"code":"NM","name":"NEW MEXICO"},"130":{"code":"NY","name":"NEW YORK"},"133":{"code":"NC","name":"NORTH CAROLINA"},"136":{"code":"ND","name":"NORTH DAKOTA"},"142":{"code":"OH","name":"OHIO"},"145":{"code":"OK","name":"OKLAHOMA"},"148":{"code":"OR","name":"OREGON"},"154":{"code":"PA","name":"PENNSYLVANIA"},"160":{"code":"RI","name":"RHODE ISLAND"},"163":{"code":"SC","name":"SOUTH CAROLINA"},"166":{"code":"SD","name":"SOUTH DAKOTA"},"169":{"code":"TN","name":"TENNESSEE"},"172":{"code":"TX","name":"TEXAS"},"175":{"code":"UT","name":"UTAH"},"178":{"code":"VT","name":"VERMONT"},"184":{"code":"VA","name":"VIRGINIA"},"187":{"code":"WA","name":"WASHINGTON"},"190":{"code":"WV","name":"WEST VIRGINIA"},"193":{"code":"WI","name":"WISCONSIN"},"196":{"code":"WY","name":"WYOMING"}}},
                "isRegionRequired": false,
                "currentRegion": "",
                "countryCode": ""
            }
        }
    }
</script>

        
            </div>

</div><div id="field_Km6Y1l290" role="group"
     class="field  wf-lg-1-1 wf-md-1-1 wf-sm-1-1 type-text webforms-fields-290 webforms-fields-f-18-form-w-25 f-18-form-customer-information-zipcode required"
    aria-labelledby="label_fieldKm6Y1l290"    >

            <label class="label"
               id="label_fieldKm6Y1l290"
            for="fieldKm6Y1l290">
            Zip Code                    </label>
    
    <div class="control" role="group" aria-labelledby="label_fieldKm6Y1l290">
        <input id='fieldKm6Y1l290'
       name='field[290]'
       type='text'
       class='input-text '
       style=''
       value=""
       placeholder="Enter Zip Code"
                  data-validate="{'required-entry':true}"
                      aria-labelledby="label_fieldKm6Y1l290"        aria-required="true"                     data-mage-init='{
            "MageMe_WebForms/js/prefill": {
                "attribute": ""
            }
       }'
/>

        
            </div>

</div><div id="field_Km6Y1l293" role="group"
     class="field  wf-lg-1-1 wf-md-1-1 wf-sm-1-1 type-country webforms-fields-293 webforms-fields-f-18-form-customer-information-country "
    aria-labelledby="label_fieldKm6Y1l293"    >

            <label class="label"
               id="label_fieldKm6Y1l293"
            for="fieldKm6Y1l293">
            Country                    </label>
    
    <div class="control" role="group" aria-labelledby="label_fieldKm6Y1l293">
            <select id='fieldKm6Y1l293'
            name='field[293]'
            class=''
            style=''
                                     aria-labelledby="label_fieldKm6Y1l293"                                         >
                                <option value="US" selected="selected">
                United States            </option>
            </select>

        
            </div>

</div></fieldset><fieldset id="fieldset_Km6Y1l137"
          class="fieldset fieldset-137 f-18-form-acknowledgement wf-lg-1-1 wf-md-1-1 wf-sm-1-1"
          style=""
          role="group"
          aria-labelledby="legend_Km6Y1l137">

            <h3 class="legend" id="legend_Km6Y1l137">
            <span>Acknowledgements and Representations</span>
        </h3>
    
    <div id="field_Km6Y1l296" role="group"
     class="field  wf-lg-1-1 wf-md-1-1 wf-sm-1-1 type-select_checkbox webforms-fields-296 webforms-fields-f-18-form-acknowledgement-checkbox required"
    aria-labelledby="label_fieldKm6Y1l296"    >

            <label class="label"
               id="label_fieldKm6Y1l296"
            >
            Acknowledgements and Representations                    </label>
    
    <div class="control" role="group" aria-labelledby="label_fieldKm6Y1l296">
        
<div>
    
            <div class='field choice option-0'
                 style=''
            >
                <input id='fieldKm6Y1l2960'
                       name='field[296][]'
                       type='checkbox'
                       value="I have read code sections 18 U.S.C. § 1716 (G) (2) (1-4) and 15 U.S.C. § 1244, as stated above, or have obtained legal advice concerning the same, and will fully comply. I agree that I am purchasing this/these Automatic/Butterfly knife/knives as a qualified person under these laws to receive same. Moreover, I have familiarized myself with any state and/or local laws  that might apply to me and will fully comply."
                       class='checkbox'
                                                  data-validate="{'validate-one-required-by-name':true, 'validate-options-checkbox-min':'1'}"
                                              data-msg-validate-options-checkbox-min="You should accept the agreement"                       data-uid="Km6Y1l296"
                       aria-labelledby="fieldKm6Y1l2960_label label_fieldKm6Y1l296"
                                                              />
                <label id="fieldKm6Y1l2960_label"
                       for='fieldKm6Y1l2960'
                >I have read code sections 18 U.S.C. § 1716 (G) (2) (1-4) and 15 U.S.C. § 1244, as stated above, or have obtained legal advice concerning the same, and will fully comply. I agree that I am purchasing this/these Automatic/Butterfly knife/knives as a qualified person under these laws to receive same. Moreover, I have familiarized myself with any state and/or local laws  that might apply to me and will fully comply.</label>
                
            </div>

            </div>

        
            </div>

</div></fieldset>
    
    <div id="submitKm6Y1l" class="actions-toolbar">
    <div class="primary">
        <button type="submit" class="action submit primary "
                id="webform_Km6Y1l_submit_button"
                title="Submit"
                name="submit_button_Km6Y1l">
            <span>Submit</span>
        </button>
    </div>
    <div class="secondary">
        <div class="please-wait" id="webform_Km6Y1l_sending_data"
             style="display:none;">
            <div class="loading-indicator"></div>
            <span id="webform_Km6Y1l_progress_text">Sending...</span>
        </div>
    </div>
</div></form>


        
    </div>

    <script type="text/x-magento-init">
    {
        "#webform_Km6Y1l": {
            "MageMe_WebForms/js/submit": {
                "url": "https://kershaw.kaiusa.com/webforms/form/submit/ajax/1/",
                "uid": "Km6Y1l",
                "isAjax": true,
                "isDisplayedAfterSubmission": false,
                "isScrolledAfterSubmission": false,
                "useCaptcha": false,
                "responseName": "",
                "messageSuccess": "Success!",
                "messageError": "Error",
                "messageCaptcha": "Please click on the Captcha",
                "messageRedirecting": "Redirecting",
                "messageComplete": "Complete",
                "messageUnknownError": "Unknown error(s) occurred"
            }
        }
    }
</script>
<script type="text/x-magento-init">
    {
        "*": {
            "BlueAcorn_SigningRestriction/js/webform-submit-after": {}
        }
    }
</script>


<script>
    require(["jquery"], function ($) {
        // prevent from accidental submit by hitting enter button
        $('form input').keydown(function (e) {
            if (e.keyCode === 13) {
                var inputs = $(this).parents("form").eq(0).find(":input");
                if (inputs[inputs.index(this) + 1] != null) {
                    inputs[inputs.index(this) + 1].focus();
                }
                e.preventDefault();
                return false;
            }
        });
    });

    </script>


<script defer>
    (() => {
        var evt = document.createEvent("Event");
        evt.initEvent("mm_webform_loadedKm6Y1l", false, false);
        window.dispatchEvent(evt);
    })();
</script>
        <div class="signing-restriction-response-wrapper">
                    <div class="signing-restriction-f-18-success-block signing-restriction-hide">
                <style>#html-body [data-pb-style=AIYV5PK]{display:flex;flex-direction:column}</style><div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-background-type="image" data-video-loop="true" data-video-play-only-visible="true" data-video-lazy-load="true" data-video-fallback-src="" data-element="inner" data-pb-style="AIYV5PK"><div data-content-type="html" data-appearance="default" data-element="main" data-decoded="true"><img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/f-18-success.svg" alt=""/>
        </div><h2 data-content-type="heading" data-appearance="default" data-element="main">
            f-18 form successfully submitted
        </h2><div data-content-type="text" data-appearance="default" data-element="main">
            <p id="FWVCLEW" style="text-align: center;">
                A confirmation will be sent to your email shortly. You can find your signed form in your <a title="Account" href="/customer/account" target="_blank" rel="noopener">Account</a>.
            </p>
        </div></div></div>            </div>
                    <div class="signing-restriction-f-18-decline-block signing-restriction-hide">
                <style>#html-body [data-pb-style=SDL524E]{display:flex;flex-direction:column}</style><div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-background-type="image" data-video-loop="true" data-video-play-only-visible="true" data-video-lazy-load="true" data-video-fallback-src="" data-element="inner" data-pb-style="SDL524E"><div data-content-type="html" data-appearance="default" data-element="main" data-decoded="true"><img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/f-18-warning.svg" alt=""/>
        </div><h2 data-content-type="heading" data-appearance="default" data-element="main">
            Please note, you cannot add to cart without signing the f-18 agreement
        </h2></div></div>            </div>
            </div>
    <button type="button" class="action decline">
        Decline    </button>
    <button type="button" class="action sign primary signing-restriction-hide">
        Sign Agreement    </button>
    <button type="button" class="action exit signing-restriction-hide">
        Decline and Exit    </button>
    <div class="signing-restriction-form-element">
        <div data-content-type="row" data-appearance="contained" data-element="main">
    <div class="signing-restriction-logos" data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" style="justify-content: flex-start; display: flex; flex-direction: column; background-position: left top; background-size: cover; background-repeat: no-repeat; background-attachment: scroll; border-style: none; border-width: 1px; border-radius: 0px; margin: 50px 0px 10px; padding: 0px;">
        <figure data-content-type="image" data-appearance="full-width" data-element="main" style="text-align: center; margin: 0px; padding: 0px; border-style: none;">
            <img class="pagebuilder-mobile-hidden" src="https://kershaw.kaiusa.com/media/wysiwyg/logos-desktop.png" alt="Stores Logos" title="Stores Logos" data-element="desktop_image" style="border-style: none; border-width: 1px; border-radius: 0px; max-width: 100%; height: auto;">
            <img class="pagebuilder-mobile-only" src="https://kershaw.kaiusa.com/media/wysiwyg/logos-mobile.png" alt="Stores Logos" title="Stores Logos" data-element="mobile_image" style="border-style: none; border-width: 1px; border-radius: 0px; max-width: 100%; height: auto;">
        </figure>
    </div>
</div>        <div data-content-type="row" data-appearance="contained" data-element="main">
    <div class="signing-restriction-contacts" data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-background-type="image" data-video-loop="true" data-video-play-only-visible="true" data-video-lazy-load="true" data-video-fallback-src="" data-element="inner" style="justify-content: flex-start; display: flex; flex-direction: column; background-position: left top; background-size: cover; background-repeat: no-repeat; background-attachment: scroll; border-style: none; border-width: 1px; border-radius: 0px; margin: 0px; padding: 0px;">
        <div data-content-type="text" data-appearance="default" data-element="main" style="border-style: none; border-width: 1px; border-radius: 0px; margin: 0px; padding: 0px;">
            <ul>
                <li>1800 SW Teton Avenue</li>
                <li>Tualatin, OR 97062</li>
                <li>Phone: 503-682-1966</li>
                <li>Toll Free: 800-325-2891</li>
                <li>Fax: 503-682-7168</li>
                <li>kaiusa.com</li>
            </ul>
        </div>
    </div>
</div>    </div>
</div>

<script type="text/x-magento-init">
        {
            ".signing-restriction-modal": {
                "signingRestrictionModal": {
                    "modalClass": "signing-restriction"
                }
            }
        }
</script>

<script>
    window.signingRestriction = {
        enabled: '1',
        allowedGroupId: '5'
    };
</script>

<div id="signing-restriction-authentication"
     data-bind="scope:'signingRestrictionAuthentication', style: {display: 'none'}">
        <script>window.authenticationPopup = {"autocomplete":"off","customerRegisterUrl":"https:\/\/kershaw.kaiusa.com\/customer\/account\/create\/","customerForgotPasswordUrl":"https:\/\/kershaw.kaiusa.com\/customer\/account\/forgotpassword\/","baseUrl":"https:\/\/kershaw.kaiusa.com\/","customerLoginUrl":"https:\/\/kershaw.kaiusa.com\/customer\/ajax\/login\/"}</script>    <div class="block-authentication"
         data-bind="afterRender: setModalElement, blockLoader: isLoading"
         style="display: none">
        <div class="titles-wrapper">
            <h3 data-bind="text: modalTitle"></h3>
            <p data-bind="text: modalSubTitle"></p>
            <button class="action-close" data-role="closeBtn" type="button">
                <span data-bind="i18n: 'Close'"></span>
            </button>
        </div>
        <div class="blocks-wrapper">
            <div class="block block-new-customer"
                 data-bind="attr: {'data-label': $t('or')}">
                <div class="block-title">
                    <h2 id="signing-modal-block-new-customer-heading"
                        role="heading"
                        aria-level="2"
                        data-bind="i18n: 'Sign Up'"></h2>
                </div>
                <div class="block-content" aria-labelledby="signing-modal-block-new-customer-heading">
                    <p data-bind="text: modalSignUpNote"></p>
                    <div class="actions-toolbar">
                        <div class="primary">
                            <a class="action action-register primary" data-bind="attr: {href: registerUrl}">
                                <span data-bind="i18n: 'Create an Account'"></span>
                            </a>
                        </div>
                    </div>
                </div>
            </div>
            <div class="block block-customer-login"
                 data-bind="attr: {'data-label': $t('or')}">
                <div class="block-title">
                    <h2 id="signing-modal-block-customer-login-heading"
                        role="heading"
                        aria-level="2"
                        data-bind="i18n: 'Log In'"></h2>
                </div>
                <!-- ko foreach: getRegion('messages') -->
                <!-- ko template: getTemplate() --><!-- /ko -->
                <!--/ko-->
                <!-- ko foreach: getRegion('before') -->
                <!-- ko template: getTemplate() --><!-- /ko -->
                <!-- /ko -->
                <div class="block-content" aria-labelledby="signing-modal-block-customer-login-heading">
                    <form class="form form-login"
                          method="post"
                          data-bind="event: {submit: login }"
                          id="signing-modal-login-form">
                        <div class="fieldset login" data-bind="attr: {'data-hasrequired': $t('* Required Fields')}">
                            <div class="field email required">
                                <label class="label" for="signing-modal-customer-email">
                                    <span data-bind="i18n: 'Email'"></span>
                                </label>
                                <div class="control">
                                    <input name="username"
                                           id="signing-modal-customer-email"
                                           type="email"
                                           class="input-text"
                                           data-mage-init='{"mage/trim-input":{}}'
                                           data-bind="attr: {
                                               autocomplete: autocomplete,
                                               placeholder: $t('Enter email address')
                                           }"
                                           data-validate="{required:true, 'validate-email':true}">
                                </div>
                            </div>
                            <div class="field password required">
                                <label for="signing-modal-pass" class="label">
                                    <span data-bind="i18n: 'Password'"></span>
                                </label>
                                <div class="control">
                                    <input name="password"
                                           type="password"
                                           class="input-text"
                                           id="signing-modal-pass"
                                           data-bind="attr: {
                                               autocomplete: autocomplete,
                                               placeholder: $t('Enter password')
                                           }"
                                           data-validate="{required:true}">
                                </div>
                            </div>
                            <!-- ko foreach: getRegion('additional-login-form-fields') -->
                            <!-- ko template: getTemplate() --><!-- /ko -->
                            <!-- /ko -->
                            <div
    class="field-recaptcha"
    id="recaptcha-7a57adcd245b36cf3d4dc0598526a7030e4a7d7d-container"
    data-bind="scope:'recaptcha-7a57adcd245b36cf3d4dc0598526a7030e4a7d7d'"
>
    <!-- ko template: getTemplate() --><!-- /ko -->
</div>

<script type="text/x-magento-init">
{
    "#recaptcha-7a57adcd245b36cf3d4dc0598526a7030e4a7d7d-container": {
        "Magento_Ui/js/core/app": {"components":{"recaptcha-7a57adcd245b36cf3d4dc0598526a7030e4a7d7d":{"settings":{"rendering":{"sitekey":"6Lc2KLoUAAAAAHriReRcKp_k3FuADvgGNHEOHyyn","badge":"inline","size":"invisible","theme":"light","hl":""},"invisible":true},"component":"Magento_ReCaptchaFrontendUi\/js\/reCaptcha","reCaptchaId":"recaptcha-7a57adcd245b36cf3d4dc0598526a7030e4a7d7d"}}}    }
}
</script>
                            <div class="actions-toolbar">
                                <input name="context" type="hidden" value="checkout" />
                                <div class="primary">
                                    <button type="submit" class="action action-login primary"
                                            name="send" id="signing-modal-send2">
                                        <span data-bind="i18n: 'Sign In'"></span>
                                    </button>
                                </div>
                                <div class="secondary">
                                    <a class="action" data-bind="attr: {href: forgotPasswordUrl}">
                                        <span data-bind="i18n: 'Forgot your password?'"></span>
                                    </a>
                                </div>
                            </div>
                        </div>
                    </form>
                </div>
            </div>
        </div>
    </div>
    <script type="text/x-magento-init">
        {
            "#signing-restriction-authentication": {
                "Magento_Ui/js/core/app": {
                    "components": {
                        "signingRestrictionAuthentication": {
                            "component": "BlueAcorn_SigningRestriction/js/view/signing-restriction-authentication",
                            "modalTitle": "Please\u0020log\u0020in\u0020below\u0020to\u0020sign\u0020the\u0020Automatic\u0020Knife\u0020release\u0020Form",
                            "modalSubTitle": "To\u0020purchase\u0020an\u0020automatic\u0020knife,\u0020you\u0020must\u0020meet\u0020certain\u0020Federal\u0020criteria.\u0020Signing\u0020the\u0020Form\u000A\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020certifies\u0020that\u0020you\u0020meet\u0020one\u0020or\u0020more\u0020of\u0020the\u0020requirements.\u000A\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020",
                            "modalSignUpNote": "Creating\u0020an\u0020account\u0020has\u0020many\u0020benefits\u003A\u0020See\u0020order\u0020and\u0020shipping\u0020statuses,\u0020track\u0020order\u000A\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020history,\u0020and\u0020check\u0020out\u0020faster.\u000A\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020\u0020",
                            "children": {
                                "messages": {
                                    "displayArea": "messages",
                                    "component": "Magento_Ui/js/view/messages"
                                }
                            }
                        }
                    }
                }
            },
            "*": {
                "Magento_Ui/js/block-loader": "https\u003A\u002F\u002Fkershaw.kaiusa.com\u002Fstatic\u002Fversion1713440747\u002Ffrontend\u002FBlueAcorn\u002Fkershaw\u002Fen_US\u002Fimages\u002Floader\u002D1.gif"
            }
        }
    </script>
</div>
<!-- Yotpo - Add body class -->
<script>
    (function(){require(["jquery"],function($){$(document).ready(function() {$('body').addClass('yotpo-yotpo-is-enabled');});});})();
</script>
<!--/ Yotpo - Add body class -->
<!-- Yotpo - Widget Script -->
    <script>
        (function e(){var e=document.createElement("script");e.type="text/javascript",e.async=true,e.src="//staticw2.yotpo.com/1J0qHOW27JZkeBkKRjpLiYw16Ms2Dzc7qDH3fXl8/widget.js";var t=document.getElementsByTagName("script")[0];t.parentNode.insertBefore(e,t)})();
    </script>
<!--/ Yotpo - Widget Script -->
    <script data-role="msrp-popup-template" type="text/x-magento-template">
    <div id="map-popup-click-for-price" class="map-popup">
        <div class="popup-header">
            <strong class="title" id="map-popup-heading-price"></strong>
        </div>
        <div class="popup-content">
            <div class="map-info-price" id="map-popup-content">
                <div class="price-box">
                    <div class="map-msrp" id="map-popup-msrp-box">
                        <span class="label">Price</span>
                        <span class="old-price map-old-price" id="map-popup-msrp">
                            <span class="price"></span>
                        </span>
                    </div>
                    <div class="map-price" id="map-popup-price-box">
                        <span class="label">Actual Price</span>
                        <span id="map-popup-price" class="actual-price"></span>
                    </div>
                </div>
                <form action="" method="POST" class="map-form-addtocart">
                    <input type="hidden" name="product" class="product_id" value="" />
                    <button type="button"
                            title="Add to Cart"
                            class="action tocart primary">
                        <span>Add to Cart</span>
                    </button>
                    <div class="additional-addtocart-box">
                                            </div>
                </form>
            </div>
            <div class="map-text" id="map-popup-text">
                Our price is lower than the manufacturer&#039;s &quot;minimum advertised price.&quot; As a result, we cannot show you the price in catalog or the product page. <br><br> You have no obligation to purchase the product once you know the price. You can simply remove the item from your cart.            </div>
        </div>
    </div>
    </script>
    <script data-role="msrp-info-template" type="text/x-magento-template">
    <div id="map-popup-what-this" class="map-popup">
        <div class="popup-header">
            <strong class="title" id="map-popup-heading-what-this"></strong>
        </div>
        <div class="popup-content">
            <div class="map-help-text" id="map-popup-text-what-this">
                Our price is lower than the manufacturer&#039;s &quot;minimum advertised price.&quot; As a result, we cannot show you the price in catalog or the product page. <br><br> You have no obligation to purchase the product once you know the price. You can simply remove the item from your cart.            </div>
        </div>
    </div>
    </script>
<script type="text/x-magento-init">
{
    ".product-slider-home .product-items": {
        "productListHover": {}
    }
}
</script>
<div data-content-type="row" data-appearance="full-width" data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-element="main" data-pb-style="60AF739B1A23A"><div class="row-full-width-inner" data-element="inner"><div data-content-type="block" data-appearance="default" data-element="main" data-pb-style="60AF739B1A251"><div class="widget block block-static-block">
    <style>#html-body [data-pb-style=K63JVJ4]{justify-content:flex-start;display:flex;flex-direction:column;background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll;border-style:none;border-width:1px;border-radius:0;margin:0 0 10px;padding:0}#html-body [data-pb-style=YS500P1]{min-height:640px;border-style:none;border-width:1px;border-radius:0;margin:0;padding:0}#html-body [data-pb-style=DHW19XL]{margin:0}#html-body [data-pb-style=X5GIBOP]{background-color:#eaeaea;background-position:left top;background-size:cover;background-repeat:no-repeat;border-style:none;border-width:1px;border-radius:0;text-align:right;min-height:640px}#html-body [data-pb-style=FKVBEGV]{min-height:640px;padding:40px;background-color:transparent}#html-body [data-pb-style=BUECGHH]{margin:0}#html-body [data-pb-style=IJW6LCN]{background-color:#eaeaea;background-position:left top;background-size:cover;background-repeat:no-repeat;border-style:none;border-width:1px;border-radius:0;text-align:right;min-height:640px}#html-body [data-pb-style=CSHVWB7]{min-height:640px;padding:40px;background-color:transparent}#html-body [data-pb-style=NHL2LNB]{margin:0}#html-body [data-pb-style=AK73FL9]{background-color:#eaeaea;background-position:left top;background-size:cover;background-repeat:no-repeat;border-style:none;border-width:1px;border-radius:0;text-align:right;min-height:640px}#html-body [data-pb-style=EXQHW57]{min-height:640px;padding:40px;background-color:transparent}#html-body [data-pb-style=DW3PJDA]{margin:0}#html-body [data-pb-style=YEK67FE]{background-color:#eaeaea;background-position:left top;background-size:cover;background-repeat:no-repeat;border-style:none;border-width:1px;border-radius:0;text-align:right;min-height:640px}#html-body [data-pb-style=E0O749T]{min-height:640px;padding:40px;background-color:transparent}#html-body [data-pb-style=OP9QBX8]{margin:0}#html-body [data-pb-style=P8YTDVF]{background-color:#eaeaea;background-position:left top;background-size:cover;background-repeat:no-repeat;border-style:none;border-width:1px;border-radius:0;text-align:right;min-height:640px}#html-body [data-pb-style=FUR6KG4]{min-height:640px;padding:40px;background-color:transparent}#html-body [data-pb-style=SSEN2PL]{margin:0}#html-body [data-pb-style=I254NMJ]{background-color:#eaeaea;background-position:left top;background-size:cover;background-repeat:no-repeat;border-style:none;border-width:1px;border-radius:0;text-align:right;min-height:640px}#html-body [data-pb-style=D7J6N2M]{min-height:640px;padding:40px;background-color:transparent}#html-body [data-pb-style=F3KP620]{margin:0}#html-body [data-pb-style=N0DO6UN]{background-color:#eaeaea;background-position:left top;background-size:cover;background-repeat:no-repeat;border-style:none;border-width:1px;border-radius:0;text-align:right;min-height:640px}#html-body [data-pb-style=A4C3UB9]{min-height:640px;padding:40px;background-color:transparent}</style><div class="hero-container" data-content-type="row" data-appearance="full-width" data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="main" data-pb-style="K63JVJ4"><div class="row-full-width-inner" data-element="inner"><div class="pagebuilder-slider" data-content-type="slider" data-appearance="default" data-autoplay="true" data-autoplay-speed="2000" data-fade="false" data-infinite-loop="true" data-show-arrows="true" data-show-dots="true" data-slider-title="" data-centered="false" data-centered-mobile="false" data-center-padding="0px" data-center-padding-mobile="0px" data-show-arrows-mobile="false" data-show-dots-mobile="false" data-slides-to-show="1" data-slides-to-show-mobile="1" data-adaptive-height="false" data-custom-pagination="false" data-element="main" data-pb-style="YS500P1"><div class="slide bottom right narrow-content" data-content-type="slide" data-slide-name="Kershaw DuraLock Knife lifestyle" data-appearance="poster" data-show-button="never" data-show-overlay="never" data-custom-pagination-image="" data-element="main" data-pb-style="DHW19XL"><div data-element="empty_link"><div class="pagebuilder-slide-wrapper background-image-663223fd18e14 background-image-663223fd20404" data-background-images='{\"desktop_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/6105-Kindling-Slider-Desktop.png\",\"mobile_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/6105-Camping-Slider-mobile.png\"}' data-background-type="image" data-video-loop="true" data-video-play-only-visible="true" data-video-lazy-load="true" data-video-fallback-src="" aria-label="Kershaw DuraLock Knife lifestyle" data-element="wrapper" data-pb-style="X5GIBOP"><div class="pagebuilder-overlay pagebuilder-poster-overlay" data-overlay-color="" aria-label="Kershaw DuraLock Knife lifestyle image" title="" data-element="overlay" data-pb-style="FKVBEGV"><div class="pagebuilder-poster-content"><div data-element="content"><div class="content"><h1>DuraLock</h1><div class="text-container image"><div class="right-content"><p>DuraLock knives are fully ambidextrous, safe, easy to close, and fun.</p><a tabindex="-1" href="https://kershaw.kaiusa.com/catalogsearch/result/?q=duralock"><button class="primary" aria-label="Shop for DuraLock knives">Shop</button></a></div></div></div></div></div></div></div><style type="text/css">.background-image-663223fd18e14 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/6105-Kindling-Slider-Desktop.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd18e14 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/6105-Camping-Slider-mobile.png);}}@media only screen and (max-width: 640px) {.background-image-663223fd18e14 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/6105-Camping-Slider-mobile.png);}}</style><style type="text/css">.background-image-663223fd20404 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/6105-Kindling-Slider-Desktop.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd20404 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/6105-Camping-Slider-mobile.png);}}@media only screen and (max-width: 640px) {.background-image-663223fd20404 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/6105-Camping-Slider-mobile.png);}}</style></div></div><div class="slide bottom right narrow-content" data-content-type="slide" data-slide-name="Kershaw Automatic Knife with firearms" data-appearance="poster" data-show-button="never" data-show-overlay="never" data-custom-pagination-image="" data-element="main" data-pb-style="BUECGHH"><div data-element="empty_link"><div class="pagebuilder-slide-wrapper background-image-663223fd18e7b background-image-663223fd20484" data-background-images='{\"desktop_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/9000BLK-Pistol-Slider-Desktop.png\",\"mobile_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-Automatics-mobile.jpg\"}' data-background-type="image" data-video-loop="true" data-video-play-only-visible="true" data-video-lazy-load="true" data-video-fallback-src="" aria-label="Kershaw Automatic Knife with firearms" data-element="wrapper" data-pb-style="IJW6LCN"><div class="pagebuilder-overlay pagebuilder-poster-overlay" data-overlay-color="" aria-label="Kershaw Automatic Knife with firearms" title="" data-element="overlay" data-pb-style="CSHVWB7"><div class="pagebuilder-poster-content"><div data-element="content"><div><div class="content"><h1>Automatic</h1><div class="text-container image"><div class="right-content"><p>A collection of USA-made, instant-open Kershaw knives.</p><a href="/automatic.html"><button class="primary" aria-label="Shop for Automatic knives"><span>Shop</span></button></a></div></div></div></div></div></div></div></div><style type="text/css">.background-image-663223fd18e7b {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/9000BLK-Pistol-Slider-Desktop.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd18e7b {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-Automatics-mobile.jpg);}}@media only screen and (max-width: 640px) {.background-image-663223fd18e7b {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-Automatics-mobile.jpg);}}</style><style type="text/css">.background-image-663223fd20484 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/9000BLK-Pistol-Slider-Desktop.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd20484 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-Automatics-mobile.jpg);}}@media only screen and (max-width: 640px) {.background-image-663223fd20484 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-Automatics-mobile.jpg);}}</style></div></div><div class="slide bottom right narrow-content" data-content-type="slide" data-slide-name="Kershaw Bestsellers" data-appearance="poster" data-show-button="never" data-show-overlay="never" data-custom-pagination-image="" data-element="main" data-pb-style="NHL2LNB"><div data-element="empty_link"><div class="pagebuilder-slide-wrapper background-image-663223fd18ec7 background-image-663223fd204d7" data-background-images='{\"desktop_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/Launch-13-Dirt-Bike-Slider-Desktop.png\",\"mobile_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/Launch-13-Dirt-Bike-Slider-mobile.png\"}' data-background-type="image" data-video-loop="true" data-video-play-only-visible="true" data-video-lazy-load="true" data-video-fallback-src="" aria-label="Kershaw Bestsellers" data-element="wrapper" data-pb-style="AK73FL9"><div class="pagebuilder-overlay pagebuilder-poster-overlay" data-overlay-color="" aria-label="Kershaw Bestsellers" title="" data-element="overlay" data-pb-style="EXQHW57"><div class="pagebuilder-poster-content"><div data-element="content"><div><div class="content"><h1>Bestsellers</h1><div class="text-container image"><div class="right-content"><p>A collection of Kershaw's most popular models.</p><a href="/bestsellers.html"><button class="primary" aria-label="Shop Bestsellers"><span>Shop</span></button></a></div></div></div></div></div></div></div></div><style type="text/css">.background-image-663223fd18ec7 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Launch-13-Dirt-Bike-Slider-Desktop.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd18ec7 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Launch-13-Dirt-Bike-Slider-mobile.png);}}@media only screen and (max-width: 640px) {.background-image-663223fd18ec7 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Launch-13-Dirt-Bike-Slider-mobile.png);}}</style><style type="text/css">.background-image-663223fd204d7 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Launch-13-Dirt-Bike-Slider-Desktop.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd204d7 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Launch-13-Dirt-Bike-Slider-mobile.png);}}@media only screen and (max-width: 640px) {.background-image-663223fd204d7 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Launch-13-Dirt-Bike-Slider-mobile.png);}}</style></div></div><div class="slide bottom right narrow-content" data-content-type="slide" data-slide-name="Kershaw Assisted Knife" data-appearance="poster" data-show-button="never" data-show-overlay="never" data-custom-pagination-image="" data-element="main" data-pb-style="DW3PJDA"><div data-element="empty_link"><div class="pagebuilder-slide-wrapper background-image-663223fd18f10 background-image-663223fd20520" data-background-images='{\"desktop_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-assisted-desktop_1.png\",\"mobile_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-assisted-mobile.png\"}' data-background-type="image" data-video-loop="true" data-video-play-only-visible="true" data-video-lazy-load="true" data-video-fallback-src="" aria-label="Kershaw Assisted Knife" data-element="wrapper" data-pb-style="YEK67FE"><div class="pagebuilder-overlay pagebuilder-poster-overlay" data-overlay-color="" aria-label="Kershaw Automatic Knife with firearms" title="" data-element="overlay" data-pb-style="E0O749T"><div class="pagebuilder-poster-content"><div data-element="content"><div><div class="content"><h1>Assisted</h1><div class="text-container image"><div class="right-content"><p>Kershaw&rsquo;s assisted knives make deployment easy and satisfying.</p><a href="/assisted-opening.html"><button class="primary" aria-label="Shop for Assisted knives"><span>Shop</span></button></a></div></div></div></div></div></div></div></div><style type="text/css">.background-image-663223fd18f10 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-assisted-desktop_1.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd18f10 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-assisted-mobile.png);}}@media only screen and (max-width: 640px) {.background-image-663223fd18f10 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-assisted-mobile.png);}}</style><style type="text/css">.background-image-663223fd20520 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-assisted-desktop_1.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd20520 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-assisted-mobile.png);}}@media only screen and (max-width: 640px) {.background-image-663223fd20520 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-hero-assisted-mobile.png);}}</style></div></div><div class="slide bottom right narrow-content" data-content-type="slide" data-slide-name="Kershaw Manual Knife lifestyle" data-appearance="poster" data-show-button="never" data-show-overlay="never" data-custom-pagination-image="" data-element="main" data-pb-style="OP9QBX8"><div data-element="empty_link"><div class="pagebuilder-slide-wrapper background-image-663223fd18f5a background-image-663223fd20567" data-background-images='{\"desktop_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/2043-Food-Slider-Desktop-v2.png\",\"mobile_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/2043-Food-Slider-mobile-v2.jpg\"}' data-background-type="image" data-video-loop="true" data-video-play-only-visible="true" data-video-lazy-load="true" data-video-fallback-src="" aria-label="Kershaw Manual Knife lifestyle" data-element="wrapper" data-pb-style="P8YTDVF"><div class="pagebuilder-overlay pagebuilder-poster-overlay" data-overlay-color="" aria-label="Kershaw Manual Knife lifestyle image" title="" data-element="overlay" data-pb-style="FUR6KG4"><div class="pagebuilder-poster-content"><div data-element="content"><div><div class="content"><h1>Manual</h1><div class="text-container image"><div class="right-content"><p>A variety of manual-opening mechanisms are available for many Kershaws.</p><a href="/manual.html"><button class="primary" aria-label="Shop for Manual knives"><span>Shop</span></button></a></div></div></div></div></div></div></div></div><style type="text/css">.background-image-663223fd18f5a {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/2043-Food-Slider-Desktop-v2.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd18f5a {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/2043-Food-Slider-mobile-v2.jpg);}}@media only screen and (max-width: 640px) {.background-image-663223fd18f5a {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/2043-Food-Slider-mobile-v2.jpg);}}</style><style type="text/css">.background-image-663223fd20567 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/2043-Food-Slider-Desktop-v2.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd20567 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/2043-Food-Slider-mobile-v2.jpg);}}@media only screen and (max-width: 640px) {.background-image-663223fd20567 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/2043-Food-Slider-mobile-v2.jpg);}}</style></div></div><div class="slide bottom right narrow-content" data-content-type="slide" data-slide-name="Kershaw Outdoor Knife lifestyle" data-appearance="poster" data-show-button="never" data-show-overlay="never" data-custom-pagination-image="" data-element="main" data-pb-style="SSEN2PL"><div data-element="empty_link"><div class="pagebuilder-slide-wrapper background-image-663223fd18fa1 background-image-663223fd205c0" data-background-images='{\"desktop_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/1882-Camo-Slider-Desktop-v2.png\",\"mobile_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/1882-camo-Slider-mobile.jpg\"}' data-background-type="image" data-video-loop="true" data-video-play-only-visible="true" data-video-lazy-load="true" data-video-fallback-src="" aria-label="Kershaw Outdoor Knife lifestyle" data-element="wrapper" data-pb-style="I254NMJ"><div class="pagebuilder-overlay pagebuilder-poster-overlay" data-overlay-color="" aria-label="Kershaw Outdoor Knife lifestyle image" title="" data-element="overlay" data-pb-style="D7J6N2M"><div class="pagebuilder-poster-content"><div data-element="content"><div><div class="content"><h1>Outdoors</h1><div class="text-container image"><div class="right-content"><p>A variety of fixed and folding blades suited for your next outdoor adventure.</p><a href="/outdoor.html"><button class="primary" aria-label="Shop for Outdoor knives"><span>Shop</span></button></a></div></div></div></div></div></div></div></div><style type="text/css">.background-image-663223fd18fa1 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/1882-Camo-Slider-Desktop-v2.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd18fa1 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/1882-camo-Slider-mobile.jpg);}}@media only screen and (max-width: 640px) {.background-image-663223fd18fa1 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/1882-camo-Slider-mobile.jpg);}}</style><style type="text/css">.background-image-663223fd205c0 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/1882-Camo-Slider-Desktop-v2.png);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd205c0 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/1882-camo-Slider-mobile.jpg);}}@media only screen and (max-width: 640px) {.background-image-663223fd205c0 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/1882-camo-Slider-mobile.jpg);}}</style></div></div><div class="slide bottom right narrow-content" data-content-type="slide" data-slide-name="Kershaw Butterfly Knife" data-appearance="poster" data-show-button="never" data-show-overlay="never" data-custom-pagination-image="" data-element="main" data-pb-style="F3KP620"><div data-element="empty_link"><div class="pagebuilder-slide-wrapper background-image-663223fd18ff4 background-image-663223fd2062f" data-background-images='{\"desktop_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/4950TR-Red-and-Black-Slider-Desktop_1.jpg\",\"mobile_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/4950TR-Red-and-Black-Slider-mobile_1.jpg\"}' data-background-type="image" data-video-loop="true" data-video-play-only-visible="true" data-video-lazy-load="true" data-video-fallback-src="" aria-label="Kershaw Butterfly Knife" data-element="wrapper" data-pb-style="N0DO6UN"><div class="pagebuilder-overlay pagebuilder-poster-overlay" data-overlay-color="" aria-label="Kershaw Butterfly Knife" title="" data-element="overlay" data-pb-style="A4C3UB9"><div class="pagebuilder-poster-content"><div data-element="content"><div class="content"><h1>Butterfly</h1><div class="text-container image"><div class="right-content"><p>A popular range of affordable trainers to premium butterfly knives.</p><a tabindex="-1" href="https://kershaw.kaiusa.com/catalogsearch/result/?q=butterfly"><button class="primary" aria-label="Shop for Butterfly knives">Shop</button></a></div></div></div></div></div></div></div><style type="text/css">.background-image-663223fd18ff4 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/4950TR-Red-and-Black-Slider-Desktop_1.jpg);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd18ff4 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/4950TR-Red-and-Black-Slider-mobile_1.jpg);}}@media only screen and (max-width: 640px) {.background-image-663223fd18ff4 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/4950TR-Red-and-Black-Slider-mobile_1.jpg);}}</style><style type="text/css">.background-image-663223fd2062f {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/4950TR-Red-and-Black-Slider-Desktop_1.jpg);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd2062f {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/4950TR-Red-and-Black-Slider-mobile_1.jpg);}}@media only screen and (max-width: 640px) {.background-image-663223fd2062f {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/4950TR-Red-and-Black-Slider-mobile_1.jpg);}}</style></div></div></div><div data-content-type="html" data-appearance="default" data-element="main" data-decoded="true"><script type="text/x-magento-init">
    {
    ".hero-container": {
    "heroContainerSlider": {
    }
    }
    }
    </script>
</div></div></div></div>
</div></div></div><div data-content-type="row" data-appearance="contained" data-element="main"><div class="main-home-row" data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-element="inner" data-pb-style="60AF739B1A261"><div data-content-type="block" data-appearance="default" data-element="main" data-pb-style="60AF739B1A270"><div class="widget block block-static-block">
    <style>#html-body [data-pb-style=GKLYVDW]{justify-content:flex-start;display:flex;flex-direction:column;background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll;border-style:none;border-width:1px;border-radius:0;margin:0 0 32px;padding:0 10px}#html-body [data-pb-style=UL4PRNW]{border-style:none;border-width:1px;border-radius:0;margin:0;padding:0}#html-body [data-pb-style=ADMLC4C],#html-body [data-pb-style=AEWEDE3],#html-body [data-pb-style=CHFTVJA],#html-body [data-pb-style=GL81Q49],#html-body [data-pb-style=HOI5G0O],#html-body [data-pb-style=JFONG15],#html-body [data-pb-style=N85Q299],#html-body [data-pb-style=VAEUBR8],#html-body [data-pb-style=XSI4LU6]{margin:0}</style><div data-content-type="row" data-appearance="contained" data-element="main"><div class="category-slider" data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" data-pb-style="GKLYVDW"><div class="content-slider category-slider" data-content-type="content-slider" data-appearance="default" data-slide-count="4" data-autoplay="false" data-autoplay-speed="4000" data-infinite-loop="false" data-show-arrows="true" data-show-dots="false" data-element="main" data-pb-style="UL4PRNW"><h4 class="content-slider-title" data-element="title">Shop By Category</h4><div class="content-slider-list"><div class="content-slider-link-container" data-content-type="content-slider-item" data-appearance="default" data-element="main" data-pb-style="JFONG15"><a class="content-slider-link" href="/new.html" target="" data-link-type="default" data-element="link"><img class="pagebuilder-mobile-hidden" src="https://kershaw.kaiusa.com/media/wysiwyg/Kershaw_New_ContentSlider2024.png" alt="" title="" data-element="image"><img class="pagebuilder-mobile-only" src="https://kershaw.kaiusa.com/media/wysiwyg/Kershaw_New_ContentSlider2024.png" alt="" title="" data-element="mobile_image"><div data-element="content">NEW</div></a></div><div class="content-slider-link-container" data-content-type="content-slider-item" data-appearance="default" data-element="main" data-pb-style="GL81Q49"><a class="content-slider-link" href="/usa-made.html" target="" data-link-type="default" data-element="link"><img class="pagebuilder-mobile-hidden" src="https://kershaw.kaiusa.com/media/wysiwyg/1812OLCBDividendCB_Category.png" alt="" title="" data-element="image"><img class="pagebuilder-mobile-only" src="https://kershaw.kaiusa.com/media/wysiwyg/1812OLCBDividendCB_Category.png" alt="" title="" data-element="mobile_image"><div data-element="content">USA</div></a></div><div class="content-slider-link-container" data-content-type="content-slider-item" data-appearance="default" data-element="main" data-pb-style="VAEUBR8"><a class="content-slider-link" href="/bestsellers.html" target="" data-link-type="default" data-element="link"><img class="pagebuilder-mobile-hidden" src="https://kershaw.kaiusa.com/media/wysiwyg/Kershaw_Bestsellers_ContentSlider2024.png" alt="" title="" data-element="image"><img class="pagebuilder-mobile-only" src="https://kershaw.kaiusa.com/media/wysiwyg/Kershaw_Bestsellers_ContentSlider2024.png" alt="" title="" data-element="mobile_image"><div data-element="content">Bestsellers</div></a></div><div class="content-slider-link-container" data-content-type="content-slider-item" data-appearance="default" data-element="main" data-pb-style="ADMLC4C"><a class="content-slider-link" href="/automatic.html" target="" data-link-type="default" data-element="link"><img class="pagebuilder-mobile-hidden" src="https://kershaw.kaiusa.com/media/wysiwyg/kershaw/home/7100BW_profile_220x55.png" alt="" title="" data-element="image"><img class="pagebuilder-mobile-only" src="https://kershaw.kaiusa.com/media/wysiwyg/kershaw/home/7100BW_profile_220x55.png" alt="" title="" data-element="mobile_image"><div data-element="content">Automatic</div></a></div><div class="content-slider-link-container" data-content-type="content-slider-item" data-appearance="default" data-element="main" data-pb-style="XSI4LU6"><a class="content-slider-link" href="/assisted-opening.html" target="" data-link-type="default" data-element="link"><img class="pagebuilder-mobile-hidden" src="https://kershaw.kaiusa.com/media/wysiwyg/2036Lucid_Category.png" alt="" title="" data-element="image"><img class="pagebuilder-mobile-only" src="https://kershaw.kaiusa.com/media/wysiwyg/2036Lucid_Category.png" alt="" title="" data-element="mobile_image"><div data-element="content">Assisted</div></a></div><div class="content-slider-link-container" data-content-type="content-slider-item" data-appearance="default" data-element="main" data-pb-style="N85Q299"><a class="content-slider-link" href="/manual.html" target="" data-link-type="default" data-element="link"><img class="pagebuilder-mobile-hidden" src="https://kershaw.kaiusa.com/media/wysiwyg/2038Iridium_Category.png" alt="" title="" data-element="image"><img class="pagebuilder-mobile-only" src="https://kershaw.kaiusa.com/media/wysiwyg/2038Iridium_Category.png" alt="" title="" data-element="mobile_image"><div data-element="content">Manual</div></a></div><div class="content-slider-link-container" data-content-type="content-slider-item" data-appearance="default" data-element="main" data-pb-style="AEWEDE3"><a class="content-slider-link" href="/outdoor.html" target="" data-link-type="default" data-element="link"><img class="pagebuilder-mobile-hidden" src="https://kershaw.kaiusa.com/media/wysiwyg/kershaw/home/category-front-slider-outdoor_220x55.png" alt="" title="" data-element="image"><img class="pagebuilder-mobile-only" src="https://kershaw.kaiusa.com/media/wysiwyg/kershaw/home/category-front-slider-outdoor_220x55.png" alt="" title="" data-element="mobile_image"><div data-element="content">Outdoor</div></a></div><div class="content-slider-link-container" data-content-type="content-slider-item" data-appearance="default" data-element="main" data-pb-style="HOI5G0O"><a class="content-slider-link" href="/starter-knives.html" target="" data-link-type="default" data-element="link"><img class="pagebuilder-mobile-hidden" src="https://kershaw.kaiusa.com/media/wysiwyg/Kershaw_Starter_ContentSlider.png" alt="" title="" data-element="image"><img class="pagebuilder-mobile-only" src="https://kershaw.kaiusa.com/media/wysiwyg/Kershaw_Starter_ContentSlider.png" alt="" title="" data-element="mobile_image"><div data-element="content">Starter</div></a></div><div class="content-slider-link-container" data-content-type="content-slider-item" data-appearance="default" data-element="main" data-pb-style="CHFTVJA"><a class="content-slider-link" href="/blackwash.html" target="" data-link-type="default" data-element="link"><img class="pagebuilder-mobile-hidden" src="https://kershaw.kaiusa.com/media/wysiwyg/kershaw/home/category-front-slider-BlackWash_220x55.png" alt="" title="" data-element="image"><img class="pagebuilder-mobile-only" src="https://kershaw.kaiusa.com/media/wysiwyg/kershaw/home/category-front-slider-BlackWash_220x55.png" alt="" title="" data-element="mobile_image"><div data-element="content">BlackWash</div></a></div></div></div></div></div></div>
</div><div data-content-type="block" data-appearance="default" data-element="main" data-pb-style="60AF739B1A27F"><div class="widget block block-static-block">
    <style>#html-body [data-pb-style=MW8QUUX]{justify-content:flex-start;display:flex;flex-direction:column;background-position:left top;background-size:cover;background-repeat:no-repeat no-repeat;background-attachment:scroll;border-style:none;border-width:1px;border-radius:0;margin:0 0 26px;padding:0}#html-body [data-pb-style=SMKNOXY]{margin:0}#html-body [data-pb-style=ADNG0VB]{background-position:left bottom;background-size:cover;background-repeat:no-repeat no-repeat;background-attachment:scroll;border-style:none;border-width:1px;border-radius:0;text-align:left}#html-body [data-pb-style=NXCTTI2]{border-radius:0;min-height:500px;background-color:transparent;padding:0}</style><div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" data-pb-style="MW8QUUX"><div data-content-type="banner" data-appearance="poster" data-show-button="never" data-show-overlay="always" data-element="main" data-pb-style="SMKNOXY" class="banner-shared banner-text-left"><a href="https://kershaw.kaiusa.com/catalogsearch/result/?q=duralock" target="_blank" data-link-type="default" title="" data-element="link"><div class="pagebuilder-banner-wrapper background-image-663223fd1bb54 background-image-663223fd206aa" data-background-images='{\"desktop_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/Home_Banner_1_DuraLock.jpg\",\"mobile_image\":\"https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-HomeBanner1_DuraLock_Mobile2.jpg\"}' data-background-type="image" data-video-loop="true" data-video-play-only-visible="true" data-video-lazy-load="true" data-video-fallback-src="" data-element="wrapper" data-pb-style="ADNG0VB"><div class="pagebuilder-overlay pagebuilder-poster-overlay" data-overlay-color="" aria-label="" title="" data-element="overlay" data-pb-style="NXCTTI2"><div class="pagebuilder-poster-content"><div data-element="content"><div class="color-wrapper"><div class="text-wrapper"><h1>Next Level<br>Blade Lockup</h1><h5>DuraLock</h5><button class="primary" aria-label="Shop for DuraLock knives"><span>Shop</span></button></div></div></div></div></div></div><style type="text/css">.background-image-663223fd1bb54 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Home_Banner_1_DuraLock.jpg);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd1bb54 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-HomeBanner1_DuraLock_Mobile2.jpg);}}@media only screen and (max-width: 640px) {.background-image-663223fd1bb54 {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-HomeBanner1_DuraLock_Mobile2.jpg);}}</style><style type="text/css">.background-image-663223fd206aa {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Home_Banner_1_DuraLock.jpg);}@media only screen and (max-width: 767px) and (min-width: 640px) {.background-image-663223fd206aa {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-HomeBanner1_DuraLock_Mobile2.jpg);}}@media only screen and (max-width: 640px) {.background-image-663223fd206aa {background-image: url(https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-HomeBanner1_DuraLock_Mobile2.jpg);}}</style></a></div></div></div></div>
</div><div data-content-type="block" data-appearance="default" data-element="main" data-pb-style="60AF739B1A28E"><div class="widget block block-static-block">
    <div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-element="inner" data-pb-style="60AF739A3D5BD"><div data-content-type="text" data-appearance="default" data-element="main" data-pb-style="60AF739A3D5D4"><h1>Featured Products</h1></div><div class="pagebuilder-products pagebuilder-products-enhanced product-slider-home" data-content-type="products" data-appearance="grid" data-element="main" data-pb-style="60AF739A3D5E4">        <div class="block product-slider-grid widget block-products-list grid">
        
        <div class="block-content">
            <!-- new_products_content_widget_grid-->            <div class="products-grid grid products-widget-product-grid">
                <div class="product-items scroll-bar widget-product-grid">
                                                                                    <div class="product-item">                                                                                                                <div class="flag-items-container">
                                                                            <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-1": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": ["NEW"],
                                                               "colorVal": "#231f20",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-1'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                                    <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-2": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": ["Exclusive"],
                                                               "colorVal": "#a51319",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-2'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                            </div>
                                                                            <div class="product-item-info">
                            <a href="https://kershaw.kaiusa.com/iridium-topo.html" class="product-item-photo">
                                <span class="product-image-container product-image-container-16979">
    <span class="product-image-wrapper">
        <img class="product-image-photo" src="https://kershaw.kaiusa.com/media/catalog/product/cache/853fce101d9cbe022db53d16eb227b9d/2/0/2038topo_profile_web.png" loading="lazy" width="240" height="200" alt="2038TOPO Iridium - Topo"></span>
</span>
<div aria-hidden="true">
    <style>.product-image-container-16979 {
    width: 240px;
}
.product-image-container-16979 span.product-image-wrapper {
    padding-bottom: 83.333333333333%;
}</style>    <script type="text/javascript">prodImageContainers = document.querySelectorAll(".product-image-container-16979");
for (var i = 0; i < prodImageContainers.length; i++) {
    prodImageContainers[i].style.width = "240px";
}
prodImageContainersWrappers = document.querySelectorAll(
    ".product-image-container-16979  span.product-image-wrapper"
);
for (var i = 0; i < prodImageContainersWrappers.length; i++) {
    prodImageContainersWrappers[i].style.paddingBottom = "83.333333333333%";
}</script></div>
                            </a>

                            <div class="product-item-details">
                                                                                                            <div class="yotpo bottomLine bottomline-position" data-product-id="16979" data-url="https://kershaw.kaiusa.com/iridium-topo.html"></div>                                                                    
                                <strong class="product-item-name">
                                    <a title="Iridium - Topo" href="https://kershaw.kaiusa.com/iridium-topo.html" class="product-item-link">
                                        Iridium - Topo                                    </a>
                                </strong>

                                                                    <div class="price-box price-final_price" data-role="priceBox" data-product-id="16979" data-price-box="product-id-16979">
    <span class="special-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Special Price</span>
        <span id="product-price-16979" data-price-amount="99.99" data-price-type="finalPrice" class="price-wrapper "><span class="price">$99.99</span></span>
        </span>
    </span>
    <span class="old-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Regular Price</span>
        <span id="old-price-16979" data-price-amount="109.99" data-price-type="oldPrice" class="price-wrapper "><span class="price">$109.99</span></span>
        </span>
    </span>

</div>                                
                                <div class="product-details-wrapper">
                                                                    </div>

                                                                    <div class="product-item-inner">
                                        <div class="product-item-actions">
                                                                                            <div class="actions-primary">
                                                                                                                                                                    <form data-role="tocart-form" data-product-sku="2038TOPO" action="https://kershaw.kaiusa.com/checkout/cart/add/uenc/aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v/product/16979/" method="post">
                                                            <input type="hidden" name="product" value="16979">
                                                            <input type="hidden" name="uenc" value="aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20vY2hlY2tvdXQvY2FydC9hZGQvdWVuYy9hSFIwY0hNNkx5OXJaWEp6YUdGM0xtdGhhWFZ6WVM1amIyMHYvcHJvZHVjdC8xNjk3OS8~">
                                                            <input type="hidden" name="requires_signing" value="0">
                                                            <input name="form_key" type="hidden" value="37uLAg49RuIqZp1W">                                                            <button type="submit" title="Add to Cart" class="action tocart primary">
                                                                <span>Add to Cart</span>
                                                            </button>
                                                        </form>
                                                                                                    </div>
                                                                                                                                        <div class="actions-secondary" data-role="add-to-links">
                                                                                                            <a href="#" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/wishlist\/index\/add\/","data":{"product":16979,"uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' class="action towishlist" data-action="add-to-wishlist" title="Add to my Wish List">
                                                            <span>Add to my Wish List</span>
                                                        </a>
                                                                                                                                                                                                                        <a href="#" class="action tocompare" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/catalog\/product_compare\/add\/","data":{"product":"16979","uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' title="Compare">
                                                            <span>Compare</span>
                                                        </a>
                                                                                                    </div>
                                                                                    </div>
                                    </div>
                                                            </div>
                        </div>
                                                                    </div><div class="product-item">                                                                                                                <div class="flag-items-container">
                                                                            <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-3": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": [],
                                                               "colorVal": "#231f20",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-3'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                                    <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-4": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": ["Exclusive"],
                                                               "colorVal": "#a51319",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-4'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                            </div>
                                                                            <div class="product-item-info">
                            <a href="https://kershaw.kaiusa.com/scallion-maycee-barber.html" class="product-item-photo">
                                <span class="product-image-container product-image-container-16624">
    <span class="product-image-wrapper">
        <img class="product-image-photo" src="https://kershaw.kaiusa.com/media/catalog/product/cache/853fce101d9cbe022db53d16eb227b9d/1/6/1620mb_profile_web.png" loading="lazy" width="240" height="200" alt="1620MB Scallion - Maycee Barber"></span>
</span>
<div aria-hidden="true">
    <style>.product-image-container-16624 {
    width: 240px;
}
.product-image-container-16624 span.product-image-wrapper {
    padding-bottom: 83.333333333333%;
}</style>    <script type="text/javascript">prodImageContainers = document.querySelectorAll(".product-image-container-16624");
for (var i = 0; i < prodImageContainers.length; i++) {
    prodImageContainers[i].style.width = "240px";
}
prodImageContainersWrappers = document.querySelectorAll(
    ".product-image-container-16624  span.product-image-wrapper"
);
for (var i = 0; i < prodImageContainersWrappers.length; i++) {
    prodImageContainersWrappers[i].style.paddingBottom = "83.333333333333%";
}</script></div>
                            </a>

                            <div class="product-item-details">
                                                                                                            <div class="yotpo bottomLine bottomline-position" data-product-id="16624" data-url="https://kershaw.kaiusa.com/scallion-maycee-barber.html"></div>                                                                    
                                <strong class="product-item-name">
                                    <a title="Scallion - Maycee Barber" href="https://kershaw.kaiusa.com/scallion-maycee-barber.html" class="product-item-link">
                                        Scallion - Maycee Barber                                    </a>
                                </strong>

                                                                    <div class="price-box price-final_price" data-role="priceBox" data-product-id="16624" data-price-box="product-id-16624">
    <span class="special-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Special Price</span>
        <span id="product-price-16624" data-price-amount="89.99" data-price-type="finalPrice" class="price-wrapper "><span class="price">$89.99</span></span>
        </span>
    </span>
    <span class="old-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Regular Price</span>
        <span id="old-price-16624" data-price-amount="114.99" data-price-type="oldPrice" class="price-wrapper "><span class="price">$114.99</span></span>
        </span>
    </span>

</div>                                
                                <div class="product-details-wrapper">
                                                                    </div>

                                                                    <div class="product-item-inner">
                                        <div class="product-item-actions">
                                                                                            <div class="actions-primary">
                                                                                                                                                                    <form data-role="tocart-form" data-product-sku="1620MB" action="https://kershaw.kaiusa.com/checkout/cart/add/uenc/aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v/product/16624/" method="post">
                                                            <input type="hidden" name="product" value="16624">
                                                            <input type="hidden" name="uenc" value="aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20vY2hlY2tvdXQvY2FydC9hZGQvdWVuYy9hSFIwY0hNNkx5OXJaWEp6YUdGM0xtdGhhWFZ6WVM1amIyMHYvcHJvZHVjdC8xNjYyNC8~">
                                                            <input type="hidden" name="requires_signing" value="0">
                                                            <input name="form_key" type="hidden" value="37uLAg49RuIqZp1W">                                                            <button type="submit" title="Add to Cart" class="action tocart primary">
                                                                <span>Add to Cart</span>
                                                            </button>
                                                        </form>
                                                                                                    </div>
                                                                                                                                        <div class="actions-secondary" data-role="add-to-links">
                                                                                                            <a href="#" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/wishlist\/index\/add\/","data":{"product":16624,"uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' class="action towishlist" data-action="add-to-wishlist" title="Add to my Wish List">
                                                            <span>Add to my Wish List</span>
                                                        </a>
                                                                                                                                                                                                                        <a href="#" class="action tocompare" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/catalog\/product_compare\/add\/","data":{"product":"16624","uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' title="Compare">
                                                            <span>Compare</span>
                                                        </a>
                                                                                                    </div>
                                                                                    </div>
                                    </div>
                                                            </div>
                        </div>
                                                                    </div><div class="product-item">                                                                                                                <div class="flag-items-container">
                                                                            <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-5": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": [],
                                                               "colorVal": "#231f20",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-5'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                                    <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-6": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": ["Exclusive"],
                                                               "colorVal": "#a51319",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-6'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                            </div>
                                                                            <div class="product-item-info">
                            <a href="https://kershaw.kaiusa.com/iridium-carbon-fiber-m390.html" class="product-item-photo">
                                <span class="product-image-container product-image-container-16615">
    <span class="product-image-wrapper">
        <img class="product-image-photo" src="https://kershaw.kaiusa.com/media/catalog/product/cache/853fce101d9cbe022db53d16eb227b9d/2/0/2038cfm390_profile_web.png" loading="lazy" width="240" height="200" alt="2038CFM390 Iridium - Carbon Fiber, M390"></span>
</span>
<div aria-hidden="true">
    <style>.product-image-container-16615 {
    width: 240px;
}
.product-image-container-16615 span.product-image-wrapper {
    padding-bottom: 83.333333333333%;
}</style>    <script type="text/javascript">prodImageContainers = document.querySelectorAll(".product-image-container-16615");
for (var i = 0; i < prodImageContainers.length; i++) {
    prodImageContainers[i].style.width = "240px";
}
prodImageContainersWrappers = document.querySelectorAll(
    ".product-image-container-16615  span.product-image-wrapper"
);
for (var i = 0; i < prodImageContainersWrappers.length; i++) {
    prodImageContainersWrappers[i].style.paddingBottom = "83.333333333333%";
}</script></div>
                            </a>

                            <div class="product-item-details">
                                                                                                            <div class="yotpo bottomLine bottomline-position" data-product-id="16615" data-url="https://kershaw.kaiusa.com/iridium-carbon-fiber-m390.html"></div>                                                                    
                                <strong class="product-item-name">
                                    <a title="Iridium - Carbon Fiber, M390" href="https://kershaw.kaiusa.com/iridium-carbon-fiber-m390.html" class="product-item-link">
                                        Iridium - Carbon Fiber, M390                                    </a>
                                </strong>

                                                                    <div class="price-box price-final_price" data-role="priceBox" data-product-id="16615" data-price-box="product-id-16615">
    <span class="special-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Special Price</span>
        <span id="product-price-16615" data-price-amount="199.99" data-price-type="finalPrice" class="price-wrapper "><span class="price">$199.99</span></span>
        </span>
    </span>
    <span class="old-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Regular Price</span>
        <span id="old-price-16615" data-price-amount="299.99" data-price-type="oldPrice" class="price-wrapper "><span class="price">$299.99</span></span>
        </span>
    </span>

</div>                                
                                <div class="product-details-wrapper">
                                                                    </div>

                                                                    <div class="product-item-inner">
                                        <div class="product-item-actions">
                                                                                            <div class="actions-primary">
                                                                                                                                                                    <form data-role="tocart-form" data-product-sku="2038CFM390" action="https://kershaw.kaiusa.com/checkout/cart/add/uenc/aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v/product/16615/" method="post">
                                                            <input type="hidden" name="product" value="16615">
                                                            <input type="hidden" name="uenc" value="aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20vY2hlY2tvdXQvY2FydC9hZGQvdWVuYy9hSFIwY0hNNkx5OXJaWEp6YUdGM0xtdGhhWFZ6WVM1amIyMHYvcHJvZHVjdC8xNjYxNS8~">
                                                            <input type="hidden" name="requires_signing" value="0">
                                                            <input name="form_key" type="hidden" value="37uLAg49RuIqZp1W">                                                            <button type="submit" title="Add to Cart" class="action tocart primary">
                                                                <span>Add to Cart</span>
                                                            </button>
                                                        </form>
                                                                                                    </div>
                                                                                                                                        <div class="actions-secondary" data-role="add-to-links">
                                                                                                            <a href="#" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/wishlist\/index\/add\/","data":{"product":16615,"uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' class="action towishlist" data-action="add-to-wishlist" title="Add to my Wish List">
                                                            <span>Add to my Wish List</span>
                                                        </a>
                                                                                                                                                                                                                        <a href="#" class="action tocompare" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/catalog\/product_compare\/add\/","data":{"product":"16615","uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' title="Compare">
                                                            <span>Compare</span>
                                                        </a>
                                                                                                    </div>
                                                                                    </div>
                                    </div>
                                                            </div>
                        </div>
                                                                    </div><div class="product-item">                                                                                                                <div class="flag-items-container">
                                                                            <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-7": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": ["NEW"],
                                                               "colorVal": "#231f20",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-7'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                                    <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-8": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": [],
                                                               "colorVal": "#a51319",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-8'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                            </div>
                                                                            <div class="product-item-info">
                            <a href="https://kershaw.kaiusa.com/bel-air.html" class="product-item-photo">
                                <span class="product-image-container product-image-container-16610">
    <span class="product-image-wrapper">
        <img class="product-image-photo" src="https://kershaw.kaiusa.com/media/catalog/product/cache/853fce101d9cbe022db53d16eb227b9d/6/1/6105_profile.png" loading="lazy" width="240" height="200" alt="6105 Bel Air"></span>
</span>
<div aria-hidden="true">
    <style>.product-image-container-16610 {
    width: 240px;
}
.product-image-container-16610 span.product-image-wrapper {
    padding-bottom: 83.333333333333%;
}</style>    <script type="text/javascript">prodImageContainers = document.querySelectorAll(".product-image-container-16610");
for (var i = 0; i < prodImageContainers.length; i++) {
    prodImageContainers[i].style.width = "240px";
}
prodImageContainersWrappers = document.querySelectorAll(
    ".product-image-container-16610  span.product-image-wrapper"
);
for (var i = 0; i < prodImageContainersWrappers.length; i++) {
    prodImageContainersWrappers[i].style.paddingBottom = "83.333333333333%";
}</script></div>
                            </a>

                            <div class="product-item-details">
                                                                                                            <div class="yotpo bottomLine bottomline-position" data-product-id="16610" data-url="https://kershaw.kaiusa.com/bel-air.html"></div>                                                                    
                                <strong class="product-item-name">
                                    <a title="Bel Air" href="https://kershaw.kaiusa.com/bel-air.html" class="product-item-link">
                                        Bel Air                                    </a>
                                </strong>

                                                                    <div class="price-box price-final_price" data-role="priceBox" data-product-id="16610" data-price-box="product-id-16610">
    <span class="special-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Special Price</span>
        <span id="product-price-16610" data-price-amount="199.99" data-price-type="finalPrice" class="price-wrapper "><span class="price">$199.99</span></span>
        </span>
    </span>
    <span class="old-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Regular Price</span>
        <span id="old-price-16610" data-price-amount="249.99" data-price-type="oldPrice" class="price-wrapper "><span class="price">$249.99</span></span>
        </span>
    </span>

</div>                                
                                <div class="product-details-wrapper">
                                                                    </div>

                                                                    <div class="product-item-inner">
                                        <div class="product-item-actions">
                                                                                            <div class="actions-primary">
                                                                                                                                                                                                                                        <div class="stock unavailable"><span>Out of stock</span></div>
                                                                                                                                                                                                                        </div>
                                                                                                                                        <div class="actions-secondary" data-role="add-to-links">
                                                                                                            <a href="#" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/wishlist\/index\/add\/","data":{"product":16610,"uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' class="action towishlist" data-action="add-to-wishlist" title="Add to my Wish List">
                                                            <span>Add to my Wish List</span>
                                                        </a>
                                                                                                                                                                                                                        <a href="#" class="action tocompare" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/catalog\/product_compare\/add\/","data":{"product":"16610","uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' title="Compare">
                                                            <span>Compare</span>
                                                        </a>
                                                                                                    </div>
                                                                                    </div>
                                    </div>
                                                            </div>
                        </div>
                                                                    </div><div class="product-item">                                                                                                                <div class="flag-items-container">
                                                                            <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-9": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": ["NEW"],
                                                               "colorVal": "#231f20",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-9'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                                    <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-10": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": [],
                                                               "colorVal": "#a51319",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-10'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                            </div>
                                                                            <div class="product-item-info">
                            <a href="https://kershaw.kaiusa.com/launch-19.html" class="product-item-photo">
                                <span class="product-image-container product-image-container-16607">
    <span class="product-image-wrapper">
        <img class="product-image-photo" src="https://kershaw.kaiusa.com/media/catalog/product/cache/853fce101d9cbe022db53d16eb227b9d/7/8/7851_profile.png" loading="lazy" width="240" height="200" alt="7851 Launch 19"></span>
</span>
<div aria-hidden="true">
    <style>.product-image-container-16607 {
    width: 240px;
}
.product-image-container-16607 span.product-image-wrapper {
    padding-bottom: 83.333333333333%;
}</style>    <script type="text/javascript">prodImageContainers = document.querySelectorAll(".product-image-container-16607");
for (var i = 0; i < prodImageContainers.length; i++) {
    prodImageContainers[i].style.width = "240px";
}
prodImageContainersWrappers = document.querySelectorAll(
    ".product-image-container-16607  span.product-image-wrapper"
);
for (var i = 0; i < prodImageContainersWrappers.length; i++) {
    prodImageContainersWrappers[i].style.paddingBottom = "83.333333333333%";
}</script></div>
                            </a>

                            <div class="product-item-details">
                                                                                                            <div class="yotpo bottomLine bottomline-position" data-product-id="16607" data-url="https://kershaw.kaiusa.com/launch-19.html"></div>                                                                    
                                <strong class="product-item-name">
                                    <a title="Launch 19" href="https://kershaw.kaiusa.com/launch-19.html" class="product-item-link">
                                        Launch 19                                    </a>
                                </strong>

                                                                    <div class="price-box price-final_price" data-role="priceBox" data-product-id="16607" data-price-box="product-id-16607">
    <span class="special-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Special Price</span>
        <span id="product-price-16607" data-price-amount="223.99" data-price-type="finalPrice" class="price-wrapper "><span class="price">$223.99</span></span>
        </span>
    </span>
    <span class="old-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Regular Price</span>
        <span id="old-price-16607" data-price-amount="279.99" data-price-type="oldPrice" class="price-wrapper "><span class="price">$279.99</span></span>
        </span>
    </span>

</div>                                
                                <div class="product-details-wrapper">
                                                                    </div>

                                                                    <div class="product-item-inner">
                                        <div class="product-item-actions">
                                                                                            <div class="actions-primary">
                                                                                                                                                                    <form data-role="tocart-form" data-product-sku="7851" action="https://kershaw.kaiusa.com/checkout/cart/add/uenc/aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v/product/16607/" method="post">
                                                            <input type="hidden" name="product" value="16607">
                                                            <input type="hidden" name="uenc" value="aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20vY2hlY2tvdXQvY2FydC9hZGQvdWVuYy9hSFIwY0hNNkx5OXJaWEp6YUdGM0xtdGhhWFZ6WVM1amIyMHYvcHJvZHVjdC8xNjYwNy8~">
                                                            <input type="hidden" name="requires_signing" value="1">
                                                            <input name="form_key" type="hidden" value="37uLAg49RuIqZp1W">                                                            <button type="submit" title="Add to Cart" class="action tocart primary">
                                                                <span>Add to Cart</span>
                                                            </button>
                                                        </form>
                                                                                                    </div>
                                                                                                                                        <div class="actions-secondary" data-role="add-to-links">
                                                                                                            <a href="#" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/wishlist\/index\/add\/","data":{"product":16607,"uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' class="action towishlist" data-action="add-to-wishlist" title="Add to my Wish List">
                                                            <span>Add to my Wish List</span>
                                                        </a>
                                                                                                                                                                                                                        <a href="#" class="action tocompare" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/catalog\/product_compare\/add\/","data":{"product":"16607","uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' title="Compare">
                                                            <span>Compare</span>
                                                        </a>
                                                                                                    </div>
                                                                                    </div>
                                    </div>
                                                            </div>
                        </div>
                                                                    </div><div class="product-item">                                                                                                                <div class="flag-items-container">
                                                                            <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-11": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": ["NEW"],
                                                               "colorVal": "#231f20",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-11'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                                    <script type="text/x-magento-init">
                                            {
                                                "*": {
                                                    "Magento_Ui/js/core/app": {
                                                        "components": {
                                                            "productFlags-12": {
                                                               "component": "uiComponent",
                                                               "template":"BlueAcorn_ProductList/product-flags",
                                                               "values": [],
                                                               "colorVal": "#a51319",
                                                               "backgroundColorVal": "transparent"
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        </script>
                                        <div data-bind="scope: 'productFlags-12'">
                                            <!--ko template:getTemplate() --><!-- /ko -->
                                        </div>
                                                                                                            </div>
                                                                            <div class="product-item-info">
                            <a href="https://kershaw.kaiusa.com/livewire-carbon-fiber.html" class="product-item-photo">
                                <span class="product-image-container product-image-container-16604">
    <span class="product-image-wrapper">
        <img class="product-image-photo" src="https://kershaw.kaiusa.com/media/catalog/product/cache/853fce101d9cbe022db53d16eb227b9d/9/0/9000cf_profile.png" loading="lazy" width="240" height="200" alt="9000CF Livewire - Carbon Fiber"></span>
</span>
<div aria-hidden="true">
    <style>.product-image-container-16604 {
    width: 240px;
}
.product-image-container-16604 span.product-image-wrapper {
    padding-bottom: 83.333333333333%;
}</style>    <script type="text/javascript">prodImageContainers = document.querySelectorAll(".product-image-container-16604");
for (var i = 0; i < prodImageContainers.length; i++) {
    prodImageContainers[i].style.width = "240px";
}
prodImageContainersWrappers = document.querySelectorAll(
    ".product-image-container-16604  span.product-image-wrapper"
);
for (var i = 0; i < prodImageContainersWrappers.length; i++) {
    prodImageContainersWrappers[i].style.paddingBottom = "83.333333333333%";
}</script></div>
                            </a>

                            <div class="product-item-details">
                                                                                                            <div class="yotpo bottomLine bottomline-position" data-product-id="16604" data-url="https://kershaw.kaiusa.com/livewire-carbon-fiber.html"></div>                                                                    
                                <strong class="product-item-name">
                                    <a title="Livewire - Carbon Fiber" href="https://kershaw.kaiusa.com/livewire-carbon-fiber.html" class="product-item-link">
                                        Livewire - Carbon Fiber                                    </a>
                                </strong>

                                                                    <div class="price-box price-final_price" data-role="priceBox" data-product-id="16604" data-price-box="product-id-16604">
    <span class="special-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Special Price</span>
        <span id="product-price-16604" data-price-amount="360" data-price-type="finalPrice" class="price-wrapper "><span class="price">$360.00</span></span>
        </span>
    </span>
    <span class="old-price">
        

<span class="price-container price-final_price tax weee">
            <span class="price-label">Regular Price</span>
        <span id="old-price-16604" data-price-amount="450" data-price-type="oldPrice" class="price-wrapper "><span class="price">$450.00</span></span>
        </span>
    </span>

</div>                                
                                <div class="product-details-wrapper">
                                                                    </div>

                                                                    <div class="product-item-inner">
                                        <div class="product-item-actions">
                                                                                            <div class="actions-primary">
                                                                                                                                                                    <form data-role="tocart-form" data-product-sku="9000CF" action="https://kershaw.kaiusa.com/checkout/cart/add/uenc/aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v/product/16604/" method="post">
                                                            <input type="hidden" name="product" value="16604">
                                                            <input type="hidden" name="uenc" value="aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20vY2hlY2tvdXQvY2FydC9hZGQvdWVuYy9hSFIwY0hNNkx5OXJaWEp6YUdGM0xtdGhhWFZ6WVM1amIyMHYvcHJvZHVjdC8xNjYwNC8~">
                                                            <input type="hidden" name="requires_signing" value="1">
                                                            <input name="form_key" type="hidden" value="37uLAg49RuIqZp1W">                                                            <button type="submit" title="Add to Cart" class="action tocart primary">
                                                                <span>Add to Cart</span>
                                                            </button>
                                                        </form>
                                                                                                    </div>
                                                                                                                                        <div class="actions-secondary" data-role="add-to-links">
                                                                                                            <a href="#" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/wishlist\/index\/add\/","data":{"product":16604,"uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' class="action towishlist" data-action="add-to-wishlist" title="Add to my Wish List">
                                                            <span>Add to my Wish List</span>
                                                        </a>
                                                                                                                                                                                                                        <a href="#" class="action tocompare" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/catalog\/product_compare\/add\/","data":{"product":"16604","uenc":"aHR0cHM6Ly9rZXJzaGF3LmthaXVzYS5jb20v"}}' title="Compare">
                                                            <span>Compare</span>
                                                        </a>
                                                                                                    </div>
                                                                                    </div>
                                    </div>
                                                            </div>
                        </div>
                        </div>                                    </div>
            </div>
                    </div>
    </div>
    <script type="text/x-magento-init">
        {
            "[data-role=tocart-form], .form.map.checkout": {
                "catalogAddToCart": {
                    "product_sku": "9000CF"
                }
            }
        }
    </script>
    <script>
        require([
            'jquery',
            'slick',
            'underscore',
            'responsiveRows',
            'mCustomScrollbarLib',
        ], function ($, slick, _) {
            let productScrollbarSelector = ".product-slider-grid .slick-list";
            let productScrollbar = null;

            $('.product-slider-grid .products-widget-product-grid .product-items').slick({
                dots: false,
                infinite: false,
                slidesToShow: 3,
                slidesToScroll: 1,
                responsive: [
                    {
                        breakpoint: 900,
                        settings: {
                            slidesToShow: 2,
                            slidesToScroll: 1
                        }
                    },
                    {
                        breakpoint: 768,
                        settings: {
                            slidesToShow: 1.2,
                            slidesToScroll: 1,
                            arrows: false,
                        }
                    }
                ]
            });

            /**
             * Resize the product grids
             */
            function resizeGridRows() {
                $('.products-widget-product-grid .product-items .product-item').responsiveEqualHeightGrid();
            }

            /**
             * Rebuild the ProductScrollbar
             */
            function createProductScrollBar() {
                if ($(window).width() <= 768) {
                    if (!productScrollbar) {
                        productScrollbar = $(productScrollbarSelector).mCustomScrollbar({
                            axis: "x",
                            theme: "dark",
                            autoExpandScrollbar: false,
                            advanced: {updateOnContentResize: true},
                            scrollbarPosition: 'outside',
                            scrollInertia: 200,
                            alwaysShowScrollbar: 2
                        });
                    }
                } else {
                    if (productScrollbar) {
                        $(productScrollbarSelector).mCustomScrollbar('destroy');
                        productScrollbar = null;
                    }
                }
            }

            /**
             * Re-init the MSRP widget
             *
             * This is needed due to the way the slick slider deals with responsive
             * breakpoints.
             */
            function reInitMsrp() {
                $.each($('.products-grid a.msrp-reinit'), function () {
                    $(this).attr('data-mage-init', JSON.stringify($(this).data('mage-init-template')));
                });
                $('.products-grid').trigger('contentUpdated');
            }

            resizeGridRows();
            createProductScrollBar();
            reInitMsrp();

            $(window).resize(_.debounce(function () {
                resizeGridRows();
                createProductScrollBar();
                reInitMsrp();
            }, 500));
        });
    </script>


</div></div></div><style>#html-body [data-pb-style="60AF739A3D5BD"]{justify-content: flex-start; display: flex; flex-direction: column; background-position: left top; background-size: cover; background-repeat: no-repeat; background-attachment: scroll; border-style: none; border-width: 1px; border-radius: 0px; margin: 0px 0px 10px; padding: 10px;}#html-body [data-pb-style="60AF739A3D5D4"]{border-style: none; border-width: 1px; border-radius: 0px; margin: 0px; padding: 0px;}#html-body [data-pb-style="60AF739A3D5E4"]{border-style: none; border-width: 1px; border-radius: 0px; margin: 0px; padding: 0px;}</style></div>
</div><div data-content-type="block" data-appearance="default" data-element="main" data-pb-style="60AF739B1A29D"><div class="widget block block-static-block">
    <style>#html-body [data-pb-style=JRYSPB2],#html-body [data-pb-style=VW20BI0]{background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll}#html-body [data-pb-style=JRYSPB2]{justify-content:center;display:flex;flex-direction:column;background-color:#f7f8f8;border-style:none;border-width:1px;border-radius:0;min-height:400px;margin:0;padding:10px}#html-body [data-pb-style=VW20BI0]{align-self:stretch}#html-body [data-pb-style=SECLC08]{display:flex;width:100%}#html-body [data-pb-style=KI08IJT]{justify-content:flex-start;display:flex;flex-direction:column;background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll;border-style:none;border-width:1px;border-radius:0;width:50%;margin:0;padding:10px;align-self:stretch}#html-body [data-pb-style=DL15M07]{margin:0}#html-body [data-pb-style=ERCV085],#html-body [data-pb-style=YKDCHP0]{border-style:none;border-width:1px;border-radius:0;padding:0}#html-body [data-pb-style=YKDCHP0]{justify-content:flex-start;display:flex;flex-direction:column;background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll;width:50%;margin:0;padding:10px;align-self:stretch}#html-body [data-pb-style=WOHCR97]{border-style:none;border-width:1px;border-radius:0;margin:0;padding:0}</style><div data-content-type="row" data-appearance="contained" data-element="main"><div class="video-text-block" data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" data-pb-style="JRYSPB2"><div class="pagebuilder-column-group" data-background-images="{}" data-content-type="column-group" data-appearance="default" data-grid-size="12" data-element="main" data-pb-style="VW20BI0"><div class="pagebuilder-column-line" data-content-type="column-line" data-element="main" data-pb-style="SECLC08"><div class="pagebuilder-column video-wrapper" data-content-type="column" data-appearance="full-height" data-background-images="{}" data-element="main" data-pb-style="KI08IJT"><div class="video-wrapper" data-content-type="video" data-appearance="default" data-element="main" data-pb-style="DL15M07"><div class="pagebuilder-video-inner" data-element="inner"><div class="pagebuilder-video-wrapper" data-element="wrapper" data-pb-style="ERCV085"><div class="pagebuilder-video-container"><img class="preview-poster_image" src="https://kershaw.kaiusa.com/media/wysiwyg/Kershaw-VideoCover.jpg" alt="A Kershaw Federalist knife in the open position lies in a hand comfortably. Click to play video. " data-element="poster_image"><iframe frameborder="0" allowfullscreen="" modestbranding="3" src="about:blank" data-url="https://www.youtube-nocookie.com/embed/fd8OQX9XOlg?rel=0&amp;controls=1&amp;showinfo=0&amp;autoplay=1" loading="" controls="true" title="Knife Knowledge Handle Materials" data-element="video"></iframe></div></div></div></div></div><div class="pagebuilder-column text-wrapper" data-content-type="column" data-appearance="full-height" data-background-images="{}" data-element="main" data-pb-style="YKDCHP0"><div data-content-type="html" data-appearance="default" data-element="main" data-pb-style="WOHCR97" data-decoded="true"><h2 class="desktop-only">Knife Knowledge</h2>
                    <h5>Handle Materials</h5>
                    <p>Kershaw's many handle materials are designed to take on a variety of work environments. Find out which one is right for you! </p>
                </div></div></div></div></div></div></div>
</div><div data-content-type="block" data-appearance="default" data-element="main" data-pb-style="60AF739B1A2AB"><div class="widget block block-static-block">
    </div>
</div></div></div><style>#html-body [data-pb-style="60AF739B1A23A"]{justify-content: flex-start; display: flex; flex-direction: column; background-position: left top; background-size: cover; background-repeat: no-repeat; background-attachment: scroll; border-style: none; border-width: 1px; border-radius: 0px; margin: 0px 0px 10px; padding: 0px;}#html-body [data-pb-style="60AF739B1A251"]{border-style: none; border-width: 1px; border-radius: 0px; margin: 0px; padding: 0px;}#html-body [data-pb-style="60AF739B1A261"]{justify-content: flex-start; display: flex; flex-direction: column; background-position: left top; background-size: cover; background-repeat: no-repeat; background-attachment: scroll; border-style: none; border-width: 1px; border-radius: 0px; margin: 0px 0px 10px; padding: 10px;}#html-body [data-pb-style="60AF739B1A270"]{border-style: none; border-width: 1px; border-radius: 0px; margin: 0px; padding: 0px;}#html-body [data-pb-style="60AF739B1A27F"]{border-style: none; border-width: 1px; border-radius: 0px; margin: 0px; padding: 0px;}#html-body [data-pb-style="60AF739B1A28E"]{border-style: none; border-width: 1px; border-radius: 0px; margin: 0px; padding: 0px;}#html-body [data-pb-style="60AF739B1A29D"]{border-style: none; border-width: 1px; border-radius: 0px; margin: 0px; padding: 0px;}#html-body [data-pb-style="60AF739B1A2AB"]{border-style: none; border-width: 1px; border-radius: 0px; margin: 0px; padding: 0px;}</style>
            <style type="text/css">
            .a2a_svg, .a2a_count {
                border-radius: 0% !important;
            }

                        .mp_social_share_inline, .mp_social_share_inline_under_cart {
                display: flex;
                padding-bottom: 15px;
            }

            .mp_social_share_inline {
                justify-content: flex-end;
            }

            .mp_social_share_inline_under_cart {
                justify-content: flex-start;
            }

                    </style>

        <div class="mp_social_share_inline">
            <div class="a2a_kit a2a_default_style            a2a_kit_size_32            ">
                <p class="label">Share</p>
                                                            <a class="a2a_button_facebook a2a-button-default"></a>
                                                                                <a class="a2a_button_twitter a2a-button-default"></a>
                                                                                <a class="a2a_button_pinterest a2a-button-default"></a>
                                                                                <a class="a2a_button_linkedin a2a-button-default"></a>
                                                                                <a class="a2a_button_tumblr a2a-button-default"></a>
                                    
                
                                    <a class="a2a_dd add-more-link" href="https://www.addtoany.com/share"></a>
                            </div>
        </div>

        <script type="text/javascript">
            var a2a_config = a2a_config || {};

            a2a_config.icon_color ="unset,#FFFFFF";
            a2a_config.num_services = 8;
            a2a_config.onclick = 1;
            a2a_config.thanks = {postShare: true,};
            a2a_config.exclude_services = ["facebook_messenger"];
        </script>
    

<script type="text/x-magento-init">
    {
        ".yotpo-main-widget": {
            "BlueAcorn_Accessibility/js/yotpo-accessibility": {}
        }
    }
</script>
</div></div></main><footer class="page-footer"><div class="footer-top"><div class="footer-top-container"><style>#html-body [data-pb-style=RCJHHXT]{justify-content:flex-start;display:flex;flex-direction:column;background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll;border-style:none;border-width:1px;border-radius:0;margin:0 0 10px;padding:10px}#html-body [data-pb-style=T84S3MT]{border-style:none;border-width:1px;border-radius:0;margin:0;padding:0}</style><div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" data-pb-style="RCJHHXT"><div data-content-type="html" data-appearance="default" data-element="main" data-pb-style="T84S3MT" data-decoded="true"><ul class="social-links">
    <li>
    <a href="https://www.facebook.com/KershawKnives/">
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/facebook.svg" alt="Facebook">
    </a>
    </li>
    <li>
    <a href="https://www.instagram.com/kershawknives/">
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/instagram.svg" alt="Instagram">
    </a>
    </li>
    <li>
    <a href="https://twitter.com/kershawknives">
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/twitter.svg" alt="Twitter">
    </a>
    </li>
    <li>
    <a href="https://www.youtube.com/kershawknivesusa">
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/youtube.svg" alt="Youtube">
    </a>
    </li>
 <li>
    <a href="https://www.tiktok.com/@kershawknives">
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/tiktok.svg" alt="TikTok">
    </a>
    </li>
</ul>
        </div></div></div><div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" data-pb-style="60AF739A3BD87"><div data-content-type="html" data-appearance="default" data-element="main" data-pb-style="60AF739A3BD9E" data-decoded="true"><ul class="icons-list">
    <!--<li>
        <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/made-in-usa.svg" alt="">
        <span>Made in USA</span>
    </li>-->
    <li style="float: right">
        <img src="https://kershaw.kaiusa.com/media/wysiwyg/svg/housewares/dealer/sharpening.png" alt="">
        <span><a href="/warranty">Free Lifetime Sharpening</a></span>
    </li>
</ul></div></div></div><style>#html-body [data-pb-style="60AF739A3BD87"]{justify-content: flex-start; display: flex; flex-direction: column; background-position: left top; background-size: cover; background-repeat: no-repeat; background-attachment: scroll; border-style: none; border-width: 1px; border-radius: 0px; margin: 0px 0px 10px; padding: 10px;}#html-body [data-pb-style="60AF739A3BD9E"]{border-style: none; border-width: 1px; border-radius: 0px; margin: 0px; padding: 0px;}</style></div></div><div class="footer-middle"><div class="footer-middle-container"><div class="block newsletter">
    <div class="title"><strong>Newsletter</strong></div>
    <div class="content">
        <form class="form subscribe"
            novalidate
            action="https://kershaw.kaiusa.com/newsletter/subscriber/new/"
            method="post"
            data-mage-init='{"validation": {"errorClass": "mage-error"}}'
            id="newsletter-validate-detail">
            <div class="field newsletter">
                <div class="control">
                    <label for="newsletter">
                        <span class="label">
                            Sign up for news &amp; offers:                        </span>
                        <input name="email" type="email" id="newsletter"
                               placeholder="Enter email address"
                               data-mage-init='{"mage/trim-input":{}}'
                               data-validate="{required:true, 'validate-email':true}"
                        />
                    </label>
                </div>
            </div>
            <div class="actions">
                <button class="action subscribe primary"
                        title="Submit"
                        type="submit"
                        aria-label="Subscribe">
                    <span>Submit</span>
                </button>
            </div>
        </form>
    </div>
</div>
<script type="text/x-magento-init">
    {
        "*": {
            "Magento_Customer/js/block-submit-on-send": {
                "formId": "newsletter-validate-detail"
            }
        }
    }
</script>
<style>#html-body [data-pb-style=RCJHHXT]{justify-content:flex-start;display:flex;flex-direction:column;background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll;border-style:none;border-width:1px;border-radius:0;margin:0 0 10px;padding:10px}#html-body [data-pb-style=T84S3MT]{border-style:none;border-width:1px;border-radius:0;margin:0;padding:0}</style><div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" data-pb-style="RCJHHXT"><div data-content-type="html" data-appearance="default" data-element="main" data-pb-style="T84S3MT" data-decoded="true"><ul class="social-links">
    <li>
    <a href="https://www.facebook.com/KershawKnives/">
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/facebook.svg" alt="Facebook">
    </a>
    </li>
    <li>
    <a href="https://www.instagram.com/kershawknives/">
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/instagram.svg" alt="Instagram">
    </a>
    </li>
    <li>
    <a href="https://twitter.com/kershawknives">
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/twitter.svg" alt="Twitter">
    </a>
    </li>
    <li>
    <a href="https://www.youtube.com/kershawknivesusa">
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/youtube.svg" alt="Youtube">
    </a>
    </li>
 <li>
    <a href="https://www.tiktok.com/@kershawknives">
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/tiktok.svg" alt="TikTok">
    </a>
    </li>
</ul>
        </div></div></div>    <div class="footer-store-switcher">
        <div class="footer-store-switcher-inner">
            <strong class="label switcher-label">
                <span>Shop Our Other Brands</span>
            </strong>
            <div class="switcher-content">
                <style>#html-body [data-pb-style=DVLXRBW]{justify-content:flex-start;display:flex;flex-direction:column;background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll;border-style:none;border-width:1px;border-radius:0;margin:0 0 10px;padding:10px}#html-body [data-pb-style=HHQRWOO]{border-style:none;border-width:1px;border-radius:0;margin:0;padding:0}</style><div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" data-pb-style="DVLXRBW"><div data-content-type="html" data-appearance="default" data-element="main" data-pb-style="HHQRWOO" data-decoded="true"><ul class="websites-list">
    <li>
    <a href="https://zt.kaiusa.com/" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/stores\/store\/redirect\/","data":{"___store":"zt","___from_store":"kershaw","uenc":"aHR0cHM6Ly96dC5rYWl1c2EuY29tL2Ntcy9pbmRleC9pbmRleC8~"}}'>
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/zt-gray.png" alt="Zero Tolerance Logo">
    </a>
    </li>
    <li>
    <a href="https://shun.kaiusa.com/" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/stores\/store\/redirect\/","data":{"___store":"shun","___from_store":"kershaw","uenc":"aHR0cHM6Ly9zaHVuLmthaXVzYS5jb20vY21zL2luZGV4L2luZGV4Lw~~"}}'>
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/shun-gray.png" alt="Shun Logo">
    </a>
    </li>
    <li>
    <a href="https://housewares.kaiusa.com/" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/stores\/store\/redirect\/","data":{"___store":"housewares","___from_store":"kershaw","uenc":"aHR0cHM6Ly9ob3VzZXdhcmVzLmthaXVzYS5jb20vY21zL2luZGV4L2luZGV4Lw~~"}}'>
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/kai-housewares-gray.png" alt="Housewares Logo">
    </a>
    </li>
    <li>
    <a href="https://kasho.kaiusa.com/" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/stores\/store\/redirect\/","data":{"___store":"kasho","___from_store":"kershaw","uenc":"aHR0cHM6Ly9rYXNoby5rYWl1c2EuY29tL2Ntcy9pbmRleC9pbmRleC8~"}}'>
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/kasho-gray.png" alt="Kasho Logo">
    </a>
    </li>
    <li>
    <a href="https://www.kaiusa.com/" data-post='{"action":"https:\/\/kershaw.kaiusa.com\/stores\/store\/redirect\/","data":{"___store":"default","___from_store":"kershaw","uenc":"aHR0cHM6Ly93d3cua2FpdXNhLmNvbS9jbXMvaW5kZXgvaW5kZXgv"}}'>
    <img src="https://kershaw.kaiusa.com/static/version1713440747/frontend/BlueAcorn/kershaw/en_US/images/icons/kai-usa-gray.png" alt="Kai USA Logo">
    </a>
    </li>
    </ul>
</div></div></div>            </div>
        </div>
    </div>
</div></div><div class="footer content"><div class="footer-columns"><style>#html-body [data-pb-style=BJUQ5KQ],#html-body [data-pb-style=JP0QP09]{background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll}#html-body [data-pb-style=BJUQ5KQ]{justify-content:flex-start;display:flex;flex-direction:column;border-style:none;border-width:1px;border-radius:0;margin:0 0 10px;padding:10px}#html-body [data-pb-style=JP0QP09]{align-self:stretch}#html-body [data-pb-style=JYJVTTH]{display:flex;width:100%}#html-body [data-pb-style=HHUEKD5],#html-body [data-pb-style=MGPSGG6],#html-body [data-pb-style=PF8JPO9],#html-body [data-pb-style=TBBFNHJ]{justify-content:flex-start;display:flex;flex-direction:column;background-position:left top;background-size:cover;background-repeat:no-repeat;background-attachment:scroll;border-style:none;border-width:1px;border-radius:0;width:25%;margin:0;padding:10px;align-self:stretch}#html-body [data-pb-style=HAIHKX9],#html-body [data-pb-style=ROPV6A5],#html-body [data-pb-style=WXWM408],#html-body [data-pb-style=YQB1K7H]{border-style:none;border-width:1px;border-radius:0;margin:0;padding:0}</style><div data-content-type="row" data-appearance="contained" data-element="main"><div data-enable-parallax="0" data-parallax-speed="0.5" data-background-images="{}" data-video-fallback-src="" data-element="inner" data-pb-style="BJUQ5KQ"><div class="pagebuilder-column-group" data-background-images="{}" data-content-type="column-group" data-appearance="default" data-grid-size="12" data-element="main" data-pb-style="JP0QP09"><div class="pagebuilder-column-line" data-content-type="column-line" data-element="main" data-pb-style="JYJVTTH"><div class="pagebuilder-column" data-content-type="column" data-appearance="full-height" data-background-images="{}" data-element="main" data-pb-style="HHUEKD5"><div data-content-type="html" data-appearance="default" data-element="main" data-pb-style="HAIHKX9" data-decoded="true"><div class="footer-nav" data-mage-init='{ "ba.mobileAccordion": {"maxWidth": 1023} }'>
    <button id="shop-title-label" class="footer-nav-title title">Shop</button>
    <ul class="footer-nav-list" id="shop-title">
    <li><a href="new.html">New</a></li>
    <li><a href="featured.html">Featured</a></li>
    <li><a href="bestsellers.html">Bestsellers</a></li>
    <li><a href="coming-soon.html">Coming Soon</a></li>
    <li><a href="view-all.html">View All</a></li>
    </ul>
    </div>
</div></div><div class="pagebuilder-column" data-content-type="column" data-appearance="full-height" data-background-images="{}" data-element="main" data-pb-style="TBBFNHJ"><div data-content-type="html" data-appearance="default" data-element="main" data-pb-style="YQB1K7H" data-decoded="true"><div class="footer-nav" data-mage-init='{ "ba.mobileAccordion": {"maxWidth": 1023} }'>
    <button id="learn-title-label" class="footer-nav-title title">Learn</button>
    <ul class="footer-nav-list" id="learn-title">
    <li><a href="/buying-guide">Buying Guide</a></li>
    <li><a href="/product-care">Product Care</a></li>
    <li><a href="/usage-safety">Usage & Safety</a></li>
    <li><a href="/opening-systems">Opening Systems</a></li>
    <li><a href="/lock-types">Lock Types</a></li>
    <li><a href="/pocketclips">Pocketclips</a></li>
    <li><a href="/blade-styles">Blade Styles</a></li>
    <li><a href="/blade-steels">Blade Steels</a></li>
    <li><a href="/blade-coatings-finishes">Blade Coatings & Finishes</a></li>
    <li><a href="/blade-edges-grinds">Blade Edges & Grinds</a></li>
    <li><a href="/handle-materials">Handle Materials</a></li>
    <li><a href="/knife-anatomy">Knife Anatomy</a></li>
    </ul>
    </div>
</div></div><div class="pagebuilder-column" data-content-type="column" data-appearance="full-height" data-background-images="{}" data-element="main" data-pb-style="PF8JPO9"><div data-content-type="html" data-appearance="default" data-element="main" data-pb-style="ROPV6A5" data-decoded="true"><div class="footer-nav" data-mage-init='{ "ba.mobileAccordion": {"maxWidth": 1023} }'>
    <button id="support-title-label" class="footer-nav-title title">Support</button>
    <ul class="footer-nav-list" id="support-title">
    <li><a href="/contact-us">Contact Us</a></li>
    <li><a href="/storelocator/">Find a Dealer</a></li>
    <li><a href="/faq">FAQ</a></li>
    <li><a href="/customer-service">Customer Service</a></li>
    <li><a href="/catalog">Catalogs</a></li>
    <li><a href="/warranty">Warranty & Service</a></li>
    <li><a href="https://kershaw.kaiusa.com/warranty#tab-form-2">Replacement Parts</a></li>
    <li><a href="/shipping-returns">Shipping & Returns</a></li>
    <li><a href="/counterfeits">Counterfeits</a></li>
    <li><a href="/discontinued.html">Discontinued</a></li>
    <li><a href="/sales/guest/form/">Order Information</a></li>
    </ul>
    </div>
</div></div><div class="pagebuilder-column" data-content-type="column" data-appearance="full-height" data-background-images="{}" data-element="main" data-pb-style="MGPSGG6"><div data-content-type="html" data-appearance="default" data-element="main" data-pb-style="WXWM408" data-decoded="true"><div class="footer-nav" data-mage-init='{ "ba.mobileAccordion": {"maxWidth": 1023} }'>
    <button id="about-title-label" class="footer-nav-title title">About</button>
    <ul class="footer-nav-list" id="about-title">
    <li><a href="/history">Kershaw History</a></li>
    <li><a href="/about-us">About Us</a></li>
    <li><a href="/reviews">Reviews</a></li>
    <li><a href="https://kershaw.kaiusa.com/proposition-65/">Proposition 65</a></li>
    <li><a href="/manufacturing">Manufacturing</a></li>
    <li><a href="/become-a-dealer">Become a Dealer</a></li>
    <li><a href="/dealer-resources">Dealer Resources</a></li>
    <li><a href="/careers">Careers</a></li>
    <li><a href="/contact-us">Donation Requests</a></li>
    <li><a href="/covid-19-response">Covid-19</a></li>
    </ul>
    </div>

</div></div></div></div></div></div></div>    <div class="store-data">
        <div class="store-info">
            <div class="footer-logo">
                <img src="https&#x3A;&#x2F;&#x2F;kershaw.kaiusa.com&#x2F;static&#x2F;version1713440747&#x2F;frontend&#x2F;BlueAcorn&#x2F;kershaw&#x2F;en_US&#x2F;images&#x2F;logo.svg"
                     alt="Footer&#x20;Logo"/>
            </div>
            <div class="footer-addr">
                <p class="title">Kai USA Ltd</p>
                <p class="address">18600 SW Teton Ave</p>
                <p class="address">
                    Tualatin,
                        OR,
                        97062,
                        US                </p>
                <p class="phone">1-800-325-2891</p>
                                                                                                <small class="copyright">
    <span>© 2024 KAI USA LTD</span>
</small>
                                                </div>
        </div>
        <ul class="footer-secondary-nav">
    <li><a class="link" href="https://kershaw.kaiusa.com/terms-conditions/">Terms</a></li>
    <li><a class="link" href="https://kershaw.kaiusa.com/privacy-policy-cookie-restriction-mode/">Privacy</a></li>
</ul>
    </div>
<div
    class="field-recaptcha"
    id="recaptcha-caa20ac351216e6f76edced1efe7c61fff5f4796-container"
    data-bind="scope:'recaptcha-caa20ac351216e6f76edced1efe7c61fff5f4796'"
>
    <!-- ko template: getTemplate() --><!-- /ko -->
</div>

<script>
    require(['jquery', 'domReady!'], function ($) {
        $('#recaptcha-caa20ac351216e6f76edced1efe7c61fff5f4796-container')
            .appendTo('#newsletter-validate-detail');
    });
</script>

<script type="text/x-magento-init">
{
    "#recaptcha-caa20ac351216e6f76edced1efe7c61fff5f4796-container": {
        "Magento_Ui/js/core/app": {"components":{"recaptcha-caa20ac351216e6f76edced1efe7c61fff5f4796":{"settings":{"rendering":{"sitekey":"6Lc2KLoUAAAAAHriReRcKp_k3FuADvgGNHEOHyyn","badge":"bottomright","size":"invisible","theme":"light","hl":""},"invisible":true},"component":"Magento_ReCaptchaFrontendUi\/js\/reCaptcha","reCaptchaId":"recaptcha-caa20ac351216e6f76edced1efe7c61fff5f4796"}}}    }
}
</script>
</div></footer><script type="text/x-magento-init">
        {
            "*": {
                "Magento_Ui/js/core/app": {
                    "components": {
                        "storage-manager": {
                            "component": "Magento_Catalog/js/storage-manager",
                            "appendTo": "",
                            "storagesConfiguration" : {"recently_viewed_product":{"requestConfig":{"syncUrl":"https:\/\/kershaw.kaiusa.com\/catalog\/product\/frontend_action_synchronize\/"},"lifetime":"1000","allowToSendRequest":null},"recently_compared_product":{"requestConfig":{"syncUrl":"https:\/\/kershaw.kaiusa.com\/catalog\/product\/frontend_action_synchronize\/"},"lifetime":"1000","allowToSendRequest":null},"product_data_storage":{"updateRequestConfig":{"url":"https:\/\/kershaw.kaiusa.com\/rest\/kershaw\/V1\/products-render-info"},"requestConfig":{"syncUrl":"https:\/\/kershaw.kaiusa.com\/catalog\/product\/frontend_action_synchronize\/"},"allowToSendRequest":null}}                        }
                    }
                }
            }
        }
</script>

<div data-role="signifyd-fingerprint" data-bind="scope: 'signifyd-fingerprint'"></div>

<script type="text/x-magento-init">
{
    "[data-role=signifyd-fingerprint]": {
        "Magento_Ui/js/core/app": {"components":{"signifyd-fingerprint":{"component":"Signifyd_Connect\/js\/view\/signifyd-fingerprint"}}}    }
}
</script>
<script type="text/x-magento-init">
    {
        "*": {
            "BlueAcorn_Accessibility/js/desktop": {}
        }
    }
</script>
<script type="text/x-magento-init">
    {
        "*": {
            "BlueAcorn_Accessibility/js/pagebuilder/video-focus": {}
        }
    }
</script>
<script>
    require(['jquery', 'iframeResizer' ],
        function ($) {
            $(function () {
                waitUntilExists(function() { return $('.embedded-iframe').length; }, function() {
                    var iframe = $('.embedded-iframe'),
                        headerHeight = $('header').outerHeight(),
                        windowHeight = $(window).innerHeight(),
                        availableHeight =  windowHeight - headerHeight - 70,
                        isOldIE = (navigator.userAgent.indexOf("MSIE") !== -1);
                    iframe.css({'height': availableHeight + 'px'});

                    iframe.on('load', function(){
                        iFrameResize({
                            log: false,
                            minHeight: availableHeight,
                            resizeFrom: 'parent',
                            scrolling: true,
                            inPageLinks: true,
                            autoResize: true,
                            heightCalculationMethod: isOldIE ? 'max' : 'bodyScroll',
                            onInit: function(iframe) {
                                iframe.style.height = availableHeight + 'px';
                            },
                            onResized: function(messageData) {
                                setTimeout(function() {
                                    messageData.iframe.style.visibility = 'visible';
                                }, 300);
                            },
                            onMessage: function(messageData) {
                                if (history.pushState && messageData.message.hasOwnProperty('trackNo')) {
                                    var newUrl = window.location.protocol + '//' + window.location.host + window.location.pathname.replace(/\/$/, '') + '/' + messageData.message.trackNo;
                                    window.history.pushState({path:newUrl}, '', newUrl);
                                }
                            }
                        }, '.embedded-iframe');
                    });

                }, function() { });
                function waitUntilExists(isReady, success, error, count, interval){
                    if (count === undefined) {
                        count = 300;
                    }
                    if (interval === undefined) {
                        interval = 20;
                    }
                    if (isReady()) {
                        success();
                        return;
                    }
                    setTimeout(function(){
                        if (!count) {
                            if (error !== undefined) {
                                error();
                            }
                        } else {
                            waitUntilExists(isReady, success, error, count -1, interval);
                        }
                    }, interval);
                }
            });
        });
</script>
</div>    <script type="text/javascript">window.NREUM||(NREUM={});NREUM.info={"beacon":"bam.nr-data.net","licenseKey":"666a992a3c","applicationID":"303996656","transactionName":"MQBSbUAHWhZSU0IKDghKcVpGD1sLHFNbEE4PC1RcSkldC1dVTg==","queueTime":0,"applicationTime":713,"atts":"HUdRGwgdSRg=","errorBeacon":"bam.nr-data.net","agent":""}</script></body>
</html>
